package main

import (
        "context"
        "os"
        "syscall"

        "github.com/AlekSi/pointer"
        "github.com/jfk9w-go/based"
        "github.com/jfk9w-go/confi"
        "github.com/pkg/errors"

        "github.com/jfk9w/hoarder/internal/captcha"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        "github.com/jfk9w/hoarder/internal/jobs/lkdr"
        "github.com/jfk9w/hoarder/internal/jobs/tinkoff"
        "github.com/jfk9w/hoarder/internal/logs"
        "github.com/jfk9w/hoarder/internal/selenium"
        "github.com/jfk9w/hoarder/internal/triggers"
        "github.com/jfk9w/hoarder/internal/triggers/schedule"
        "github.com/jfk9w/hoarder/internal/triggers/stdin"
        "github.com/jfk9w/hoarder/internal/triggers/telegram"
        "github.com/jfk9w/hoarder/internal/triggers/xmpp"
)

type Config struct {
        Schema string `yaml:"$schema,omitempty" default:"https://raw.githubusercontent.com/jfk9w/hoarder/master/config/schema.json"`

        Dump *struct {
                Schema bool `yaml:"schema,omitempty" doc:"Вывод схемы конфигурации в YAML."`
                Values bool `yaml:"values,omitempty" doc:"Вывод значений конфигурации по умолчанию в JSON."`
        } `yaml:"dump,omitempty" doc:"Вывод параметров конфигурации в стандартный поток вывода.\n\nПредназначены для использования как CLI-параметры."`

        Log logs.Config `yaml:"log,omitempty" doc:"Настройки логирования для библиотеки slog."`

        Firefly *struct {
                firefly.Config `yaml:",inline"`
                Enabled        bool `yaml:"enabled,omitempty" doc:"Включить синхронизацию с Firefly III."`
        } `yaml:"firefly,omitempty" doc:"Настройки подключения к Firefly III."`

        Schedule *struct {
                schedule.Config `yaml:",inline"`
                Enabled         bool `yaml:"enabled,omitempty" doc:"Включить фоновую синхронизацию."`
        } `yaml:"schedule,omitempty" doc:"Настройки фоновой синхронизации."`

        Stdin *struct {
                Enabled bool `yaml:"enabled,omitempty" doc:"Включение интерактивной командной строки."`
        } `yaml:"stdin,omitempty" doc:"Настройки управления через интерактивную командную строку."`

        XMPP *struct {
                xmpp.Config `yaml:",inline"`
                Enabled     bool `yaml:"enabled,omitempty" doc:"Включение XMPP-триггера."`
        } `yaml:"xmpp,omitempty" doc:"Настройки XMPP-триггера."`

        Telegram *struct {
                telegram.Config `yaml:",inline"`
                Enabled         bool `yaml:"enabled,omitempty" doc:"Включение Telegram-триггера."`
        } `yaml:"telegram,omitempty" doc:"Настройки Telegram-триггера."`

        LKDR *struct {
                lkdr.Config `yaml:",inline"`
                Enabled     bool `yaml:"enabled,omitempty" doc:"Включает загрузку данных из сервиса ФНС \"Мои чеки онлайн\"."`
        } `yaml:"lkdr,omitempty" doc:"Настройка загрузки данных из сервиса ФНС \"Мои чеки онлайн\"."`

        Tinkoff *struct {
                tinkoff.Config `yaml:",inline"`
                Enabled        bool `yaml:"enabled,omitempty" doc:"Включает загрузку данных из Т-Банка."`
        } `yaml:"tinkoff,omitempty" doc:"Настройка загрузки данных из Т-Банка"`

        Selenium *struct {
                selenium.Config `yaml:",inline"`
                Enabled         bool `yaml:"enabled,omitempty" doc:"Включает аутентификацию через Selenium."`
        } `yaml:"selenium,omitempty" doc:"Параметры Selenium."`

        Captcha *captcha.Config `yaml:"captcha,omitempty" doc:"Настройки для решения капчи."`
}

func main() {
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel()

        cfg, schema, err := confi.Get[Config](ctx, "hoarder")
        if err != nil {
                panic(err)
        }

        if pointer.Get(cfg.Dump).Schema {
                dump(schema, confi.JSON)
                return
        }

        if pointer.Get(cfg.Dump).Values {
                cfg.Dump = nil
                dump(cfg, confi.JSON)
                return
        }

        log := logs.Get(cfg.Log)
        defer log.Info("shutdown")

        clock := based.StandardClock

        var fireflyClient firefly.Invoker
        if cfg := cfg.Firefly; pointer.Get(cfg).Enabled {
                fireflyClient, err = firefly.NewDefaultClient(firefly.ClientParams{
                        Config: cfg.Config,
                })

                if err != nil {
                        panic(errors.Wrap(err, "create firefly registry"))
                }
        }

        var captchaSolver captcha.TokenProvider
        if cfg := cfg.Captcha; cfg != nil {
                captchaSolver, err = captcha.NewTokenProvider(cfg, clock)
                if err != nil {
                        panic(errors.Wrap(err, "create captcha solver"))
                }
        }

        var seleniumService *selenium.Service
        if cfg := cfg.Selenium; pointer.Get(cfg).Enabled {
                seleniumService, err = selenium.NewService(selenium.ServiceParams{
                        Config: cfg.Config,
                })
                if err != nil {
                        panic(errors.Wrap(err, "init selenium service"))
                }

                defer seleniumService.Stop()
        }

        jobs := new(jobs.Registry)

        if cfg := cfg.LKDR; pointer.Get(cfg).Enabled {
                job, err := lkdr.NewJob(ctx, lkdr.JobParams{
                        Clock:         clock,
                        Logger:        log,
                        Config:        cfg.Config,
                        CaptchaSolver: captchaSolver,
                })

                if err != nil {
                        panic(errors.Wrapf(err, "create %s job", lkdr.JobID))
                }

                jobs.Register(job)
        }

        if cfg := cfg.Tinkoff; pointer.Get(cfg).Enabled {
                job, err := tinkoff.NewJob(ctx, tinkoff.JobParams{
                        Clock:    clock,
                        Logger:   log,
                        Config:   cfg.Config,
                        Firefly:  fireflyClient,
                        Selenium: seleniumService,
                })

                if err != nil {
                        panic(errors.Wrapf(err, "create %s job", tinkoff.JobID))
                }

                defer job.Close()
                jobs.Register(job)
        }

        triggers := triggers.NewRegistry(log)

        if cfg := cfg.Schedule; pointer.Get(cfg).Enabled {
                trigger, err := schedule.NewTrigger(schedule.TriggerParams{
                        Clock:  clock,
                        Config: cfg.Config,
                })

                if err != nil {
                        panic(errors.Wrap(err, "create schedule trigger"))
                }

                triggers.Register(trigger)
        }

        if cfg := cfg.Stdin; pointer.Get(cfg).Enabled {
                trigger, err := stdin.NewTrigger(stdin.TriggerParams{
                        Clock: clock,
                })

                if err != nil {
                        panic(errors.Wrap(err, "create stdin trigger"))
                }

                triggers.Register(trigger)
        }

        if cfg := cfg.XMPP; pointer.Get(cfg).Enabled {
                trigger, err := xmpp.NewTrigger(xmpp.TriggerParams{
                        Clock:  clock,
                        Config: cfg.Config,
                })

                if err != nil {
                        panic(errors.Wrap(err, "create xmpp trigger"))
                }

                triggers.Register(trigger)
        }

        if cfg := cfg.Telegram; pointer.Get(cfg).Enabled {
                trigger, err := telegram.NewTrigger(telegram.TriggerParams{
                        Clock:  clock,
                        Config: cfg.Config,
                        Logger: log,
                })

                if err != nil {
                        panic(errors.Wrap(err, "create telegram trigger"))
                }

                triggers.Register(trigger)
        }

        triggers.Run(ctx, jobs)
        defer triggers.Close()

        if err := based.AwaitSignal(ctx, syscall.SIGINT, syscall.SIGTERM); err != nil {
                panic(err)
        }
}

func dump(value any, codec confi.Codec) {
        if err := codec.Marshal(value, os.Stdout); err != nil {
                panic(err)
        }
}

package captcha

import (
        "context"

        "github.com/jfk9w-go/based"
        "github.com/jfk9w-go/rucaptcha-api"
        "github.com/pkg/errors"
)

type Config struct {
        RucaptchaKey string `yaml:"rucaptchaKey,omitempty" doc:"API-ключ для сервиса rucaptcha.com."`
}

type TokenProvider interface {
        GetCaptchaToken(ctx context.Context, userAgent, siteKey, pageURL string) (string, error)
}

func NewTokenProvider(cfg *Config, clock based.Clock) (TokenProvider, error) {
        if key := cfg.RucaptchaKey; key != "" {
                client, err := rucaptcha.NewClient(rucaptcha.ClientParams{
                        Config: rucaptcha.Config{
                                Key: key,
                        },
                        Clock: clock,
                })

                if err != nil {
                        return nil, errors.Wrap(err, "create rucaptcha client")
                }

                return &rucaptchaTokenProvider{client: client}, nil
        }

        return nil, nil
}

package captcha

import (
        "context"

        "github.com/jfk9w-go/rucaptcha-api"
)

type rucaptchaClient interface {
        Solve(ctx context.Context, in rucaptcha.SolveIn) (*rucaptcha.SolveOut, error)
}

type rucaptchaTokenProvider struct {
        client rucaptchaClient
}

func (p *rucaptchaTokenProvider) GetCaptchaToken(ctx context.Context, userAgent, siteKey, pageURL string) (string, error) {
        solved, err := p.client.Solve(ctx, &rucaptcha.YandexSmartCaptchaIn{
                UserAgent: userAgent,
                SiteKey:   siteKey,
                PageURL:   pageURL,
        })

        if err != nil {
                return "", err
        }

        return solved.Answer, nil
}

package common

import (
        "errors"
        "sync"
)

type MultiMutex[K comparable] struct {
        keyed  map[K]*sync.Mutex
        global sync.RWMutex
}

func (m *MultiMutex[K]) TryLock(key K) (func(), error) {
        mu := m.get(key)
        if ok := mu.TryLock(); !ok {
                return nil, errors.New("locked")
        }

        return mu.Unlock, nil
}

func (m *MultiMutex[K]) get(key K) *sync.Mutex {
        var (
                mu *sync.Mutex
                ok bool
        )

        m.global.RLock()
        if m.keyed != nil {
                mu, ok = m.keyed[key]
        }

        m.global.RUnlock()
        if ok {
                return mu
        }

        m.global.Lock()
        defer m.global.Unlock()
        if m.keyed == nil {
                m.keyed = make(map[K]*sync.Mutex)
        } else if mu, ok = m.keyed[key]; ok {
                return mu
        }

        mu = new(sync.Mutex)
        m.keyed[key] = mu
        return mu
}

package common

import (
        "context"

        "github.com/jfk9w-go/based"
        "github.com/pkg/errors"
)

var (
        ErrDuplicateQuestion = errors.New("duplicate question")
        ErrNoQuestions       = errors.New("no questions")
)

type (
        AskFunc[K comparable] func(ctx context.Context, key K) error

        Asker[K comparable, V any] interface {
                Ask(ctx context.Context, key K, fn AskFunc[K]) (V, error)
        }

        Answerer[K comparable, V any] interface {
                Answer(ctx context.Context, key K, answer V) error
        }

        Questions[K comparable, V any] interface {
                Asker[K, V]
                Answerer[K, V]
        }
)

type questions[K comparable, V any] struct {
        questions map[K]chan V
        mu        based.RWMutex
}

func NewQuestions[K comparable, V any]() Questions[K, V] {
        return &questions[K, V]{
                questions: make(map[K]chan V),
        }
}

func (qs *questions[K, V]) createQuestion(ctx context.Context, key K, fn AskFunc[K]) (chan V, error) {
        ctx, cancel := qs.mu.Lock(ctx)
        defer cancel()
        if ctx.Err() != nil {
                return nil, ctx.Err()
        }

        if _, ok := qs.questions[key]; ok {
                return nil, ErrDuplicateQuestion
        }

        if err := fn(ctx, key); err != nil {
                return nil, errors.Wrap(err, "ask")
        }

        question := make(chan V)
        qs.questions[key] = question

        return question, nil
}

func (qs *questions[K, V]) getQuestion(ctx context.Context, key K) (chan V, error) {
        ctx, cancel := qs.mu.Lock(ctx)
        defer cancel()
        if ctx.Err() != nil {
                return nil, ctx.Err()
        }

        question, ok := qs.questions[key]
        if !ok {
                return nil, ErrNoQuestions
        }

        return question, nil
}

func (qs *questions[K, V]) deleteQuestion(key K) {
        _, cancel := qs.mu.Lock(context.Background())
        defer cancel()
        delete(qs.questions, key)
}

func (qs *questions[K, V]) Ask(ctx context.Context, key K, fn AskFunc[K]) (answer V, err error) {
        question, err := qs.createQuestion(ctx, key, fn)
        if err != nil {
                err = errors.Wrap(err, "create question")
                return
        }

        defer qs.deleteQuestion(key)

        select {
        case answer := <-question:
                return answer, nil
        case <-ctx.Done():
                err = ctx.Err()
                return
        }
}

func (qs *questions[K, V]) Answer(ctx context.Context, key K, answer V) error {
        question, err := qs.getQuestion(ctx, key)
        if err != nil {
                return err
        }

        defer close(question)

        select {
        case question <- answer:
                return nil
        case <-ctx.Done():
                return ctx.Err()
        }
}

package common

type Stack[T any] struct {
        top    *stackNode[T]
        length int
}

type stackNode[T any] struct {
        value T
        prev  *stackNode[T]
}

func (s *Stack[T]) Pop() (T, bool) {
        if s.length == 0 || s.top == nil {
                var zero T
                return zero, false
        }

        value := s.top.value
        s.top = s.top.prev
        s.length--

        return value, true
}

func (s *Stack[T]) Push(values ...T) {
        for i := len(values) - 1; i >= 0; i-- {
                value := values[i]
                s.length++
                s.top = &stackNode[T]{
                        value: value,
                        prev:  s.top,
                }
        }
}

package common

import (
        "github.com/pkg/errors"
)

type UserMap[K, V comparable] map[K][]V

func (m UserMap[K, V]) Reverse() (map[V]K, error) {
        reverse := make(map[V]K)
        for k, vs := range m {
                for _, v := range vs {
                        if e, ok := reverse[v]; ok {
                                return nil, errors.Errorf("duplicate entries for key [%v]: [%v] and [%v]", v, e, k)
                        }

                        reverse[v] = k
                }
        }

        return reverse, nil
}

package database

import (
        "sort"

        "gorm.io/driver/mysql"
        "gorm.io/driver/postgres"
        "gorm.io/driver/sqlite"
        "gorm.io/gorm"
)

var drivers = map[Driver]func(string) gorm.Dialector{
        "postgres": postgres.Open,
        "mysql":    mysql.Open,
        "sqlite":   sqlite.Open,
}

type Driver string

func (Driver) SchemaEnum() any {
        var names []string
        for name := range drivers {
                names = append(names, string(name))
        }

        sort.Strings(names)
        return names
}

type Config struct {
        Driver Driver `yaml:"driver"`
        DSN    string `yaml:"dsn" examples:"\"file::memory:?cache=shared\", \"host=localhost port=5432 user=postgres password=postgres dbname=postgres search_path=public\""`
}

package database

import (
        "encoding/json"
        "strings"
)

func ToViaJSON[T any](source any) (target T, err error) {
        data, err := json.Marshal(source)
        if err != nil {
                return
        }

        var value any
        if err = json.Unmarshal(data, &value); err != nil {
                return
        }

        value = trim(value)
        index(value)

        data, err = json.Marshal(value)
        if err != nil {
                return
        }

        err = json.Unmarshal(data, &target)
        return
}

func trim(source any) any {
        switch source := source.(type) {
        case map[string]any:
                target := make(map[string]any, len(source))
                for key, value := range source {
                        value := trim(value)
                        if value == nil {
                                continue
                        }

                        target[key] = value
                }

                return target

        case []any:
                target := make([]any, len(source))
                for i, value := range source {
                        target[i] = trim(value)
                }

                return target

        case string:
                target := strings.Trim(source, " ")
                if target == "" {
                        return nil
                }

                return target

        default:
                return source
        }
}

func index(source any) {
        switch source := source.(type) {
        case []any:
                for i, value := range source {
                        index(value)
                        if values, ok := value.(map[string]any); ok {
                                values["dbIdx"] = i + 1
                        }
                }

        case map[string]any:
                for _, value := range source {
                        index(value)
                }
        }
}

package database

import (
        "context"
        "fmt"
        "log/slog"
        "reflect"

        "github.com/jfk9w-go/based"
        "github.com/pkg/errors"
        "gorm.io/gorm"
        "gorm.io/gorm/clause"
        "gorm.io/gorm/logger"
        "gorm.io/gorm/schema"
)

var namingStrategy = schema.NamingStrategy{
        IdentifierMaxLength: 64,
}

type Params struct {
        Clock    based.Clock  `validate:"required"`
        Logger   *slog.Logger `validate:"required"`
        Config   Config       `validate:"required"`
        Entities []any        `validate:"required"`
}

type DB struct {
        *gorm.DB
}

func Open(ctx context.Context, params Params) (DB, error) {
        if err := based.Validate(params); err != nil {
                return DB{}, err
        }

        driver, ok := drivers[params.Config.Driver]
        if !ok {
                return DB{}, errors.Errorf("unsupported driver: %s", params.Config.Driver)
        }

        db, err := gorm.Open(driver(params.Config.DSN), &gorm.Config{
                NowFunc: params.Clock.Now,
                Logger: slogLogger{
                        logger: params.Logger,
                        level:  logger.Warn,
                },
                FullSaveAssociations: true,
                NamingStrategy:       namingStrategy,
        })

        if err != nil {
                return DB{}, errors.Wrap(err, "open database")
        }

        if err := db.WithContext(ctx).AutoMigrate(params.Entities...); err != nil {
                return DB{}, errors.Wrap(err, "migrate database tables")
        }

        if params.Logger.Enabled(ctx, slog.LevelDebug) {
                db = db.Debug()
        }

        return DB{DB: db}, nil
}

func (db DB) WithContext(ctx context.Context) DB {
        db.DB = db.DB.WithContext(ctx)
        return db
}

func (db DB) Transaction(fn func(tx DB) error) error {
        return db.DB.Transaction(func(tx *gorm.DB) error {
                return fn(DB{DB: tx})
        })
}

func (db DB) Upsert(value any) *gorm.DB {
        return db.Clauses(extractUpsertClause(value)).Create(value)
}

func (db DB) UpsertInBatches(value any, batchSize int) *gorm.DB {
        return db.Clauses(extractUpsertClause(value)).CreateInBatches(value, batchSize)
}

func extractUpsertClause(entity any) clause.OnConflict {
        value := reflect.ValueOf(entity)
loop:
        for {
                switch value.Kind() {
                case reflect.Ptr:
                        value = value.Elem()
                case reflect.Slice:
                        value = value.Index(0)
                default:
                        break loop
                }
        }

        for value.Kind() == reflect.Ptr || value.Kind() == reflect.Slice {
                value = value.Elem()
        }

        if value.Kind() != reflect.Struct {
                panic(fmt.Sprintf("expected %s, got %s", reflect.Struct, value.Kind()))
        }

        cnf := clause.OnConflict{
                UpdateAll: true,
        }

        for i := 0; i < value.NumField(); i++ {
                typeField := value.Type().Field(i)
                if typeField.Anonymous || !typeField.IsExported() {
                        continue
                }

                tag := typeField.Tag.Get("gorm")
                if tag == "" {
                        continue
                }

                settings := schema.ParseTagSetting(tag, ";")
                if _, ok := settings["PRIMARYKEY"]; !ok {
                        continue
                }

                columnName := settings["COLUMN"]
                if columnName == "" {
                        columnName = namingStrategy.ColumnName("", typeField.Name)
                }

                cnf.Columns = append(cnf.Columns, clause.Column{Name: columnName})
        }

        return cnf
}

package database

import (
        "context"
        "fmt"
        "log/slog"
        "time"

        "gorm.io/gorm/logger"

        "github.com/jfk9w/hoarder/internal/logs"
)

type slogLogger struct {
        logger *slog.Logger
        level  logger.LogLevel
}

func slogLevel2logLevel(level slog.Level) logger.LogLevel {
        switch level {
        case slog.LevelDebug:
                return logger.Info
        case slog.LevelInfo:
                return logger.Info
        case slog.LevelWarn:
                return logger.Warn
        case slog.LevelError:
                return logger.Error
        }

        return 0
}

func (l slogLogger) LogMode(level logger.LogLevel) logger.Interface {
        l.level = level
        return l
}

func (l slogLogger) Info(ctx context.Context, msg string, args ...any) {
        l.log(ctx, slog.LevelInfo, fmt.Sprintf(msg, args...))
}

func (l slogLogger) Warn(ctx context.Context, msg string, args ...any) {
        l.log(ctx, slog.LevelWarn, fmt.Sprintf(msg, args...))
}

func (l slogLogger) Error(ctx context.Context, msg string, args ...any) {
        l.log(ctx, slog.LevelError, fmt.Sprintf(msg, args...))
}

func (l slogLogger) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
        if !l.logger.Enabled(ctx, slog.LevelDebug) {
                return
        }

        sql, rowsAffected := fc()

        level := slog.LevelDebug
        attrs := []slog.Attr{
                slog.Time("begin", begin),
                slog.Int64("rowsAffected", rowsAffected),
        }

        if err != nil {
                level = slog.LevelError
                attrs = append(attrs, logs.Error(err))
        }

        l.log(ctx, level, sql, attrs...)
}

func (l *slogLogger) log(ctx context.Context, level slog.Level, msg string, args ...slog.Attr) {
        if l.level < slogLevel2logLevel(level) {
                return
        }

        l.logger.LogAttrs(ctx, level, msg, args...)
}

package firefly

import (
        "net/http"

        ht "github.com/ogen-go/ogen/http"
)

type httpClient struct {
        client ht.Client
}

func (c httpClient) Do(req *http.Request) (*http.Response, error) {
        req.Header.Set("Accept", "application/json")
        return c.client.Do(req)
}

package firefly

import (
        "context"
)

type Config struct {
        ServerURL   string `yaml:"serverUrl" doc:"URL сервера Firefly III."`
        AccessToken string `yaml:"accessToken" doc:"Персональный токен доступа."`
}

func (c Config) FireflyIiiAuth(_ context.Context, _ string) (FireflyIiiAuth, error) {
        return FireflyIiiAuth{Token: c.AccessToken}, nil
}

package firefly

import (
        "github.com/jfk9w-go/based"
)

//go:generate ogen -clean -no-server -ct-alias application/vnd.api+json=application/json -target . -package firefly ./firefly-iii-2.0.9-v1-fix.yaml

type ClientParams struct {
        Config Config `validate:"required"`
}

func wrapClient(cfg *clientConfig) {
        cfg.Client = httpClient{cfg.Client}
}

func NewDefaultClient(params ClientParams) (Invoker, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        wrapClient := optionFunc[clientConfig](wrapClient)
        return NewClient(params.Config.ServerURL, params.Config, wrapClient)
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "net/http"

        "go.opentelemetry.io/otel"
        "go.opentelemetry.io/otel/metric"
        "go.opentelemetry.io/otel/trace"

        ht "github.com/ogen-go/ogen/http"
        "github.com/ogen-go/ogen/otelogen"
)

var (
        // Allocate option closure once.
        clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
)

type (
        optionFunc[C any] func(*C)
        otelOptionFunc    func(*otelConfig)
)

type otelConfig struct {
        TracerProvider trace.TracerProvider
        Tracer         trace.Tracer
        MeterProvider  metric.MeterProvider
        Meter          metric.Meter
}

func (cfg *otelConfig) initOTEL() {
        if cfg.TracerProvider == nil {
                cfg.TracerProvider = otel.GetTracerProvider()
        }
        if cfg.MeterProvider == nil {
                cfg.MeterProvider = otel.GetMeterProvider()
        }
        cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
                trace.WithInstrumentationVersion(otelogen.SemVersion()),
        )
        cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name)
}

type clientConfig struct {
        otelConfig
        Client ht.Client
}

// ClientOption is client config option.
type ClientOption interface {
        applyClient(*clientConfig)
}

var _ = []ClientOption{
        (optionFunc[clientConfig])(nil),
        (otelOptionFunc)(nil),
}

func (o optionFunc[C]) applyClient(c *C) {
        o(c)
}

func (o otelOptionFunc) applyClient(c *clientConfig) {
        o(&c.otelConfig)
}

func newClientConfig(opts ...ClientOption) clientConfig {
        cfg := clientConfig{
                Client: http.DefaultClient,
        }
        for _, opt := range opts {
                opt.applyClient(&cfg)
        }
        cfg.initOTEL()
        return cfg
}

type baseClient struct {
        cfg      clientConfig
        requests metric.Int64Counter
        errors   metric.Int64Counter
        duration metric.Float64Histogram
}

func (cfg clientConfig) baseClient() (c baseClient, err error) {
        c = baseClient{cfg: cfg}
        if c.requests, err = c.cfg.Meter.Int64Counter(otelogen.ClientRequestCount); err != nil {
                return c, err
        }
        if c.errors, err = c.cfg.Meter.Int64Counter(otelogen.ClientErrorsCount); err != nil {
                return c, err
        }
        if c.duration, err = c.cfg.Meter.Float64Histogram(otelogen.ClientDuration); err != nil {
                return c, err
        }
        return c, nil
}

// Option is config option.
type Option interface {
        ClientOption
}

// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
        return otelOptionFunc(func(cfg *otelConfig) {
                if provider != nil {
                        cfg.TracerProvider = provider
                }
        })
}

// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the otel.GetMeterProvider() is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
        return otelOptionFunc(func(cfg *otelConfig) {
                if provider != nil {
                        cfg.MeterProvider = provider
                }
        })
}

// WithClient specifies http client to use.
func WithClient(client ht.Client) ClientOption {
        return optionFunc[clientConfig](func(cfg *clientConfig) {
                if client != nil {
                        cfg.Client = client
                }
        })
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "context"
        "net/url"
        "strings"
        "time"

        "github.com/go-faster/errors"
        "go.opentelemetry.io/otel/attribute"
        "go.opentelemetry.io/otel/codes"
        "go.opentelemetry.io/otel/metric"
        semconv "go.opentelemetry.io/otel/semconv/v1.19.0"
        "go.opentelemetry.io/otel/trace"

        "github.com/ogen-go/ogen/conv"
        ht "github.com/ogen-go/ogen/http"
        "github.com/ogen-go/ogen/ogenerrors"
        "github.com/ogen-go/ogen/otelogen"
        "github.com/ogen-go/ogen/uri"
)

// Invoker invokes operations described by OpenAPI v3 specification.
type Invoker interface {
        // BulkUpdateTransactions invokes bulkUpdateTransactions operation.
        //
        // Allows you to update transactions in bulk.
        //
        // POST /v1/data/bulk/transactions
        BulkUpdateTransactions(ctx context.Context, params BulkUpdateTransactionsParams) (BulkUpdateTransactionsRes, error)
        // DefaultCurrency invokes defaultCurrency operation.
        //
        // Make this currency the default currency for the user. If the currency is not enabled, it will be
        // enabled as well.
        //
        // POST /v1/currencies/{code}/default
        DefaultCurrency(ctx context.Context, params DefaultCurrencyParams) (DefaultCurrencyRes, error)
        // DeleteAccount invokes deleteAccount operation.
        //
        // Will permanently delete an account. Any associated transactions and piggy banks are ALSO deleted.
        // Cannot be recovered from.
        //
        // DELETE /v1/accounts/{id}
        DeleteAccount(ctx context.Context, params DeleteAccountParams) (DeleteAccountRes, error)
        // DeleteAttachment invokes deleteAttachment operation.
        //
        // With this endpoint you delete an attachment, including any stored file data.
        //
        // DELETE /v1/attachments/{id}
        DeleteAttachment(ctx context.Context, params DeleteAttachmentParams) (DeleteAttachmentRes, error)
        // DeleteBill invokes deleteBill operation.
        //
        // Delete a bill. This will not delete any associated rules. Will not remove associated transactions.
        // WILL remove all associated attachments.
        //
        // DELETE /v1/bills/{id}
        DeleteBill(ctx context.Context, params DeleteBillParams) (DeleteBillRes, error)
        // DeleteBudget invokes deleteBudget operation.
        //
        // Delete a budget. Transactions will not be deleted.
        //
        // DELETE /v1/budgets/{id}
        DeleteBudget(ctx context.Context, params DeleteBudgetParams) (DeleteBudgetRes, error)
        // DeleteBudgetLimit invokes deleteBudgetLimit operation.
        //
        // Delete a budget limit.
        //
        // DELETE /v1/budgets/{id}/limits/{limitId}
        DeleteBudgetLimit(ctx context.Context, params DeleteBudgetLimitParams) (DeleteBudgetLimitRes, error)
        // DeleteCategory invokes deleteCategory operation.
        //
        // Delete a category. Transactions will not be removed.
        //
        // DELETE /v1/categories/{id}
        DeleteCategory(ctx context.Context, params DeleteCategoryParams) (DeleteCategoryRes, error)
        // DeleteCurrency invokes deleteCurrency operation.
        //
        // Delete a currency.
        //
        // DELETE /v1/currencies/{code}
        DeleteCurrency(ctx context.Context, params DeleteCurrencyParams) (DeleteCurrencyRes, error)
        // DeleteLinkType invokes deleteLinkType operation.
        //
        // Will permanently delete a link type. The links between transactions will be removed. The
        // transactions themselves remain. You cannot delete some of the system provided link types,
        // indicated by the editable=false flag when you list it.
        //
        // DELETE /v1/link-types/{id}
        DeleteLinkType(ctx context.Context, params DeleteLinkTypeParams) (DeleteLinkTypeRes, error)
        // DeleteObjectGroup invokes deleteObjectGroup operation.
        //
        // Delete a object group.
        //
        // DELETE /v1/object-groups/{id}
        DeleteObjectGroup(ctx context.Context, params DeleteObjectGroupParams) (DeleteObjectGroupRes, error)
        // DeletePiggyBank invokes deletePiggyBank operation.
        //
        // Delete a piggy bank.
        //
        // DELETE /v1/piggy-banks/{id}
        DeletePiggyBank(ctx context.Context, params DeletePiggyBankParams) (DeletePiggyBankRes, error)
        // DeleteRecurrence invokes deleteRecurrence operation.
        //
        // Delete a recurring transaction. Transactions created by the recurring transaction will not be
        // deleted.
        //
        // DELETE /v1/recurrences/{id}
        DeleteRecurrence(ctx context.Context, params DeleteRecurrenceParams) (DeleteRecurrenceRes, error)
        // DeleteRule invokes deleteRule operation.
        //
        // Delete an rule.
        //
        // DELETE /v1/rules/{id}
        DeleteRule(ctx context.Context, params DeleteRuleParams) (DeleteRuleRes, error)
        // DeleteRuleGroup invokes deleteRuleGroup operation.
        //
        // Delete a rule group.
        //
        // DELETE /v1/rule-groups/{id}
        DeleteRuleGroup(ctx context.Context, params DeleteRuleGroupParams) (DeleteRuleGroupRes, error)
        // DeleteTag invokes deleteTag operation.
        //
        // Delete an tag.
        //
        // DELETE /v1/tags/{tag}
        DeleteTag(ctx context.Context, params DeleteTagParams) (DeleteTagRes, error)
        // DeleteTransaction invokes deleteTransaction operation.
        //
        // Delete a transaction.
        //
        // DELETE /v1/transactions/{id}
        DeleteTransaction(ctx context.Context, params DeleteTransactionParams) (DeleteTransactionRes, error)
        // DeleteTransactionJournal invokes deleteTransactionJournal operation.
        //
        // Delete an individual journal (split) from a transaction.
        //
        // DELETE /v1/transaction-journals/{id}
        DeleteTransactionJournal(ctx context.Context, params DeleteTransactionJournalParams) (DeleteTransactionJournalRes, error)
        // DeleteTransactionLink invokes deleteTransactionLink operation.
        //
        // Will permanently delete link. Transactions remain.
        //
        // DELETE /v1/transaction-links/{id}
        DeleteTransactionLink(ctx context.Context, params DeleteTransactionLinkParams) (DeleteTransactionLinkRes, error)
        // DeleteUser invokes deleteUser operation.
        //
        // Delete a user. You cannot delete the user you're authenticated with. This cannot be undone. Be
        // careful!.
        //
        // DELETE /v1/users/{id}
        DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error)
        // DeleteWebhook invokes deleteWebhook operation.
        //
        // Delete a webhook.
        //
        // DELETE /v1/webhooks/{id}
        DeleteWebhook(ctx context.Context, params DeleteWebhookParams) (DeleteWebhookRes, error)
        // DeleteWebhookMessage invokes deleteWebhookMessage operation.
        //
        // Delete a webhook message. Any time a webhook is triggered the message is stored before it's sent.
        // You can delete them before or after sending.
        //
        // DELETE /v1/webhooks/{id}/messages/{messageId}
        DeleteWebhookMessage(ctx context.Context, params DeleteWebhookMessageParams) (DeleteWebhookMessageRes, error)
        // DeleteWebhookMessageAttempt invokes deleteWebhookMessageAttempt operation.
        //
        // Delete a webhook message attempt. If you delete all attempts for a webhook message, Firefly III
        // will (once again) assume all is well with the webhook message and will try to send it again.
        //
        // DELETE /v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}
        DeleteWebhookMessageAttempt(ctx context.Context, params DeleteWebhookMessageAttemptParams) (DeleteWebhookMessageAttemptRes, error)
        // DestroyData invokes destroyData operation.
        //
        // A call to this endpoint deletes the requested data type. Use it with care and always with user
        // permission.
        // The demo user is incapable of using this endpoint.
        //
        // DELETE /v1/data/destroy
        DestroyData(ctx context.Context, params DestroyDataParams) (DestroyDataRes, error)
        // DisableCurrency invokes disableCurrency operation.
        //
        // Disable a currency.
        //
        // POST /v1/currencies/{code}/disable
        DisableCurrency(ctx context.Context, params DisableCurrencyParams) (DisableCurrencyRes, error)
        // DownloadAttachment invokes downloadAttachment operation.
        //
        // This endpoint allows you to download the binary content of a transaction. It will be sent to you
        // as a download, using the content type "application/octet-stream" and content disposition
        // "attachment; filename=example.pdf".
        //
        // GET /v1/attachments/{id}/download
        DownloadAttachment(ctx context.Context, params DownloadAttachmentParams) (DownloadAttachmentRes, error)
        // EnableCurrency invokes enableCurrency operation.
        //
        // Enable a single currency.
        //
        // POST /v1/currencies/{code}/enable
        EnableCurrency(ctx context.Context, params EnableCurrencyParams) (EnableCurrencyRes, error)
        // ExportAccounts invokes exportAccounts operation.
        //
        // This endpoint allows you to export your accounts from Firefly III into a file. Currently supports
        // CSV exports only.
        //
        // GET /v1/data/export/accounts
        ExportAccounts(ctx context.Context, params ExportAccountsParams) (ExportAccountsRes, error)
        // ExportBills invokes exportBills operation.
        //
        // This endpoint allows you to export your bills from Firefly III into a file. Currently supports CSV
        // exports only.
        //
        // GET /v1/data/export/bills
        ExportBills(ctx context.Context, params ExportBillsParams) (ExportBillsRes, error)
        // ExportBudgets invokes exportBudgets operation.
        //
        // This endpoint allows you to export your budgets and associated budget data from Firefly III into a
        // file. Currently supports CSV exports only.
        //
        // GET /v1/data/export/budgets
        ExportBudgets(ctx context.Context, params ExportBudgetsParams) (ExportBudgetsRes, error)
        // ExportCategories invokes exportCategories operation.
        //
        // This endpoint allows you to export your categories from Firefly III into a file. Currently
        // supports CSV exports only.
        //
        // GET /v1/data/export/categories
        ExportCategories(ctx context.Context, params ExportCategoriesParams) (ExportCategoriesRes, error)
        // ExportPiggies invokes exportPiggies operation.
        //
        // This endpoint allows you to export your piggy banks from Firefly III into a file. Currently
        // supports CSV exports only.
        //
        // GET /v1/data/export/piggy-banks
        ExportPiggies(ctx context.Context, params ExportPiggiesParams) (ExportPiggiesRes, error)
        // ExportRecurring invokes exportRecurring operation.
        //
        // This endpoint allows you to export your recurring transactions from Firefly III into a file.
        // Currently supports CSV exports only.
        //
        // GET /v1/data/export/recurring
        ExportRecurring(ctx context.Context, params ExportRecurringParams) (ExportRecurringRes, error)
        // ExportRules invokes exportRules operation.
        //
        // This endpoint allows you to export your rules and rule groups from Firefly III into a file.
        // Currently supports CSV exports only.
        //
        // GET /v1/data/export/rules
        ExportRules(ctx context.Context, params ExportRulesParams) (ExportRulesRes, error)
        // ExportTags invokes exportTags operation.
        //
        // This endpoint allows you to export your tags from Firefly III into a file. Currently supports CSV
        // exports only.
        //
        // GET /v1/data/export/tags
        ExportTags(ctx context.Context, params ExportTagsParams) (ExportTagsRes, error)
        // ExportTransactions invokes exportTransactions operation.
        //
        // This endpoint allows you to export transactions from Firefly III into a file. Currently supports
        // CSV exports only.
        //
        // GET /v1/data/export/transactions
        ExportTransactions(ctx context.Context, params ExportTransactionsParams) (ExportTransactionsRes, error)
        // FireRule invokes fireRule operation.
        //
        // Fire the rule group on your transactions. Changes will be made by the rules in the group! Limit
        // the result if you want to.
        //
        // POST /v1/rules/{id}/trigger
        FireRule(ctx context.Context, params FireRuleParams) (FireRuleRes, error)
        // FireRuleGroup invokes fireRuleGroup operation.
        //
        // Fire the rule group on your transactions. Changes will be made by the rules in the rule group!
        // Limit the result if you want to.
        //
        // POST /v1/rule-groups/{id}/trigger
        FireRuleGroup(ctx context.Context, params FireRuleGroupParams) (FireRuleGroupRes, error)
        // GetAbout invokes getAbout operation.
        //
        // Returns general system information and versions of the (supporting) software.
        //
        // GET /v1/about
        GetAbout(ctx context.Context, params GetAboutParams) (GetAboutRes, error)
        // GetAccount invokes getAccount operation.
        //
        // Returns a single account by its ID.
        //
        // GET /v1/accounts/{id}
        GetAccount(ctx context.Context, params GetAccountParams) (GetAccountRes, error)
        // GetAccountsAC invokes getAccountsAC operation.
        //
        // Returns all accounts of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/accounts
        GetAccountsAC(ctx context.Context, params GetAccountsACParams) (GetAccountsACRes, error)
        // GetAttachment invokes getAttachment operation.
        //
        // Get a single attachment. This endpoint only returns the available metadata for the attachment.
        // Actual file data is handled in two other endpoints (see below).
        //
        // GET /v1/attachments/{id}
        GetAttachment(ctx context.Context, params GetAttachmentParams) (GetAttachmentRes, error)
        // GetAvailableBudget invokes getAvailableBudget operation.
        //
        // Get a single available budget, by ID.
        //
        // GET /v1/available-budgets/{id}
        GetAvailableBudget(ctx context.Context, params GetAvailableBudgetParams) (GetAvailableBudgetRes, error)
        // GetBasicSummary invokes getBasicSummary operation.
        //
        // Returns basic sums of the users data, like the net worth, spent and earned amounts. It is
        // multi-currency, and is used in Firefly III to populate the dashboard.
        //
        // GET /v1/summary/basic
        GetBasicSummary(ctx context.Context, params GetBasicSummaryParams) (GetBasicSummaryRes, error)
        // GetBill invokes getBill operation.
        //
        // Get a single bill.
        //
        // GET /v1/bills/{id}
        GetBill(ctx context.Context, params GetBillParams) (GetBillRes, error)
        // GetBillsAC invokes getBillsAC operation.
        //
        // Returns all bills of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/bills
        GetBillsAC(ctx context.Context, params GetBillsACParams) (GetBillsACRes, error)
        // GetBudget invokes getBudget operation.
        //
        // Get a single budget. If the start date and end date are submitted as well, the "spent" array will
        // be updated accordingly.
        //
        // GET /v1/budgets/{id}
        GetBudget(ctx context.Context, params GetBudgetParams) (GetBudgetRes, error)
        // GetBudgetLimit invokes getBudgetLimit operation.
        //
        // Get single budget limit.
        //
        // GET /v1/budgets/{id}/limits/{limitId}
        GetBudgetLimit(ctx context.Context, params GetBudgetLimitParams) (GetBudgetLimitRes, error)
        // GetBudgetsAC invokes getBudgetsAC operation.
        //
        // Returns all budgets of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/budgets
        GetBudgetsAC(ctx context.Context, params GetBudgetsACParams) (GetBudgetsACRes, error)
        // GetCategoriesAC invokes getCategoriesAC operation.
        //
        // Returns all categories of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/categories
        GetCategoriesAC(ctx context.Context, params GetCategoriesACParams) (GetCategoriesACRes, error)
        // GetCategory invokes getCategory operation.
        //
        // Get a single category.
        //
        // GET /v1/categories/{id}
        GetCategory(ctx context.Context, params GetCategoryParams) (GetCategoryRes, error)
        // GetChartAccountOverview invokes getChartAccountOverview operation.
        //
        // This endpoint returns the data required to generate a chart with basic asset account balance
        // information.
        //
        // GET /v1/chart/account/overview
        GetChartAccountOverview(ctx context.Context, params GetChartAccountOverviewParams) (GetChartAccountOverviewRes, error)
        // GetConfiguration invokes getConfiguration operation.
        //
        // Returns all editable and not-editable configuration values for this Firefly III installation.
        //
        // GET /v1/configuration
        GetConfiguration(ctx context.Context, params GetConfigurationParams) (GetConfigurationRes, error)
        // GetCron invokes getCron operation.
        //
        // Firefly III has one endpoint for its various cron related tasks. Send a GET to this endpoint
        // to run the cron. The cron requires the CLI token to be present. The cron job will fire for all
        // users.
        //
        // GET /v1/cron/{cliToken}
        GetCron(ctx context.Context, params GetCronParams) (GetCronRes, error)
        // GetCurrenciesAC invokes getCurrenciesAC operation.
        //
        // Returns all currencies of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/currencies
        GetCurrenciesAC(ctx context.Context, params GetCurrenciesACParams) (GetCurrenciesACRes, error)
        // GetCurrenciesCodeAC invokes getCurrenciesCodeAC operation.
        //
        // Returns all currencies of the user returned in a basic auto-complete array. This endpoint is
        // DEPRECATED and I suggest you DO NOT use it.
        //
        // GET /v1/autocomplete/currencies-with-code
        GetCurrenciesCodeAC(ctx context.Context, params GetCurrenciesCodeACParams) (GetCurrenciesCodeACRes, error)
        // GetCurrency invokes getCurrency operation.
        //
        // Get a single currency.
        //
        // GET /v1/currencies/{code}
        GetCurrency(ctx context.Context, params GetCurrencyParams) (GetCurrencyRes, error)
        // GetCurrentUser invokes getCurrentUser operation.
        //
        // Returns the currently authenticated user.
        //
        // GET /v1/about/user
        GetCurrentUser(ctx context.Context, params GetCurrentUserParams) (GetCurrentUserRes, error)
        // GetDefaultCurrency invokes getDefaultCurrency operation.
        //
        // Get the user's default currency.
        //
        // GET /v1/currencies/default
        GetDefaultCurrency(ctx context.Context, params GetDefaultCurrencyParams) (GetDefaultCurrencyRes, error)
        // GetLinkType invokes getLinkType operation.
        //
        // Returns a single link type by its ID.
        //
        // GET /v1/link-types/{id}
        GetLinkType(ctx context.Context, params GetLinkTypeParams) (GetLinkTypeRes, error)
        // GetObjectGroup invokes getObjectGroup operation.
        //
        // Get a single object group.
        //
        // GET /v1/object-groups/{id}
        GetObjectGroup(ctx context.Context, params GetObjectGroupParams) (GetObjectGroupRes, error)
        // GetObjectGroupsAC invokes getObjectGroupsAC operation.
        //
        // Returns all object groups of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/object-groups
        GetObjectGroupsAC(ctx context.Context, params GetObjectGroupsACParams) (GetObjectGroupsACRes, error)
        // GetPiggiesAC invokes getPiggiesAC operation.
        //
        // Returns all piggy banks of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/piggy-banks
        GetPiggiesAC(ctx context.Context, params GetPiggiesACParams) (GetPiggiesACRes, error)
        // GetPiggiesBalanceAC invokes getPiggiesBalanceAC operation.
        //
        // Returns all piggy banks of the user returned in a basic auto-complete array complemented with
        // balance information.
        //
        // GET /v1/autocomplete/piggy-banks-with-balance
        GetPiggiesBalanceAC(ctx context.Context, params GetPiggiesBalanceACParams) (GetPiggiesBalanceACRes, error)
        // GetPiggyBank invokes getPiggyBank operation.
        //
        // Get a single piggy bank.
        //
        // GET /v1/piggy-banks/{id}
        GetPiggyBank(ctx context.Context, params GetPiggyBankParams) (GetPiggyBankRes, error)
        // GetPreference invokes getPreference operation.
        //
        // Return a single preference and the value.
        //
        // GET /v1/preferences/{name}
        GetPreference(ctx context.Context, params GetPreferenceParams) (GetPreferenceRes, error)
        // GetRecurrence invokes getRecurrence operation.
        //
        // Get a single recurring transaction.
        //
        // GET /v1/recurrences/{id}
        GetRecurrence(ctx context.Context, params GetRecurrenceParams) (GetRecurrenceRes, error)
        // GetRecurringAC invokes getRecurringAC operation.
        //
        // Returns all recurring transactions of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/recurring
        GetRecurringAC(ctx context.Context, params GetRecurringACParams) (GetRecurringACRes, error)
        // GetRule invokes getRule operation.
        //
        // Get a single rule.
        //
        // GET /v1/rules/{id}
        GetRule(ctx context.Context, params GetRuleParams) (GetRuleRes, error)
        // GetRuleGroup invokes getRuleGroup operation.
        //
        // Get a single rule group. This does not include the rules. For that, see below.
        //
        // GET /v1/rule-groups/{id}
        GetRuleGroup(ctx context.Context, params GetRuleGroupParams) (GetRuleGroupRes, error)
        // GetRuleGroupsAC invokes getRuleGroupsAC operation.
        //
        // Returns all rule groups of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/rule-groups
        GetRuleGroupsAC(ctx context.Context, params GetRuleGroupsACParams) (GetRuleGroupsACRes, error)
        // GetRulesAC invokes getRulesAC operation.
        //
        // Returns all rules of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/rules
        GetRulesAC(ctx context.Context, params GetRulesACParams) (GetRulesACRes, error)
        // GetSingleConfiguration invokes getSingleConfiguration operation.
        //
        // Returns one configuration variable for this Firefly III installation.
        //
        // GET /v1/configuration/{name}
        GetSingleConfiguration(ctx context.Context, params GetSingleConfigurationParams) (GetSingleConfigurationRes, error)
        // GetSingleWebhookMessage invokes getSingleWebhookMessage operation.
        //
        // When a webhook is triggered it will store the actual content of the webhook in a webhook message.
        // You can view and analyse a single one using this endpoint.
        //
        // GET /v1/webhooks/{id}/messages/{messageId}
        GetSingleWebhookMessage(ctx context.Context, params GetSingleWebhookMessageParams) (GetSingleWebhookMessageRes, error)
        // GetSingleWebhookMessageAttempt invokes getSingleWebhookMessageAttempt operation.
        //
        // When a webhook message fails to send it will store the failure in an "attempt". You can view and
        // analyse these. Webhooks messages that receive too many attempts (failures) will not be fired. You
        // must first clear out old attempts and try again. This endpoint shows you the details of a single
        // attempt. The ID of the attempt must match the corresponding webhook and webhook message.
        //
        // GET /v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}
        GetSingleWebhookMessageAttempt(ctx context.Context, params GetSingleWebhookMessageAttemptParams) (GetSingleWebhookMessageAttemptRes, error)
        // GetTag invokes getTag operation.
        //
        // Get a single tag.
        //
        // GET /v1/tags/{tag}
        GetTag(ctx context.Context, params GetTagParams) (GetTagRes, error)
        // GetTagAC invokes getTagAC operation.
        //
        // Returns all tags of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/tags
        GetTagAC(ctx context.Context, params GetTagACParams) (GetTagACRes, error)
        // GetTransaction invokes getTransaction operation.
        //
        // Get a single transaction.
        //
        // GET /v1/transactions/{id}
        GetTransaction(ctx context.Context, params GetTransactionParams) (GetTransactionRes, error)
        // GetTransactionByJournal invokes getTransactionByJournal operation.
        //
        // Get a single transaction by underlying journal (split).
        //
        // GET /v1/transaction-journals/{id}
        GetTransactionByJournal(ctx context.Context, params GetTransactionByJournalParams) (GetTransactionByJournalRes, error)
        // GetTransactionLink invokes getTransactionLink operation.
        //
        // Returns a single link by its ID.
        //
        // GET /v1/transaction-links/{id}
        GetTransactionLink(ctx context.Context, params GetTransactionLinkParams) (GetTransactionLinkRes, error)
        // GetTransactionTypesAC invokes getTransactionTypesAC operation.
        //
        // Returns all transaction types returned in a basic auto-complete array. English only.
        //
        // GET /v1/autocomplete/transaction-types
        GetTransactionTypesAC(ctx context.Context, params GetTransactionTypesACParams) (GetTransactionTypesACRes, error)
        // GetTransactionsAC invokes getTransactionsAC operation.
        //
        // Returns all transaction descriptions of the user returned in a basic auto-complete array.
        //
        // GET /v1/autocomplete/transactions
        GetTransactionsAC(ctx context.Context, params GetTransactionsACParams) (GetTransactionsACRes, error)
        // GetTransactionsIDAC invokes getTransactionsIDAC operation.
        //
        // Returns all transactions, complemented with their ID, of the user returned in a basic
        // auto-complete array. This endpoint is DEPRECATED and I suggest you DO NOT use it.
        //
        // GET /v1/autocomplete/transactions-with-id
        GetTransactionsIDAC(ctx context.Context, params GetTransactionsIDACParams) (GetTransactionsIDACRes, error)
        // GetUser invokes getUser operation.
        //
        // Gets all info of a single user.
        //
        // GET /v1/users/{id}
        GetUser(ctx context.Context, params GetUserParams) (GetUserRes, error)
        // GetWebhook invokes getWebhook operation.
        //
        // Gets all info of a single webhook.
        //
        // GET /v1/webhooks/{id}
        GetWebhook(ctx context.Context, params GetWebhookParams) (GetWebhookRes, error)
        // GetWebhookMessageAttempts invokes getWebhookMessageAttempts operation.
        //
        // When a webhook message fails to send it will store the failure in an "attempt". You can view and
        // analyse these. Webhook messages that receive too many attempts (failures) will not be sent again.
        // You must first clear out old attempts before the message can go out again.
        //
        // GET /v1/webhooks/{id}/messages/{messageId}/attempts
        GetWebhookMessageAttempts(ctx context.Context, params GetWebhookMessageAttemptsParams) (GetWebhookMessageAttemptsRes, error)
        // GetWebhookMessages invokes getWebhookMessages operation.
        //
        // When a webhook is triggered the actual message that will be send is stored in a "message". You can
        // view and analyse these messages.
        //
        // GET /v1/webhooks/{id}/messages
        GetWebhookMessages(ctx context.Context, params GetWebhookMessagesParams) (GetWebhookMessagesRes, error)
        // InsightExpenseAsset invokes insightExpenseAsset operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by asset account.
        //
        // GET /v1/insight/expense/asset
        InsightExpenseAsset(ctx context.Context, params InsightExpenseAssetParams) (InsightExpenseAssetRes, error)
        // InsightExpenseBill invokes insightExpenseBill operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by (any) bill.
        //
        // GET /v1/insight/expense/bill
        InsightExpenseBill(ctx context.Context, params InsightExpenseBillParams) (InsightExpenseBillRes, error)
        // InsightExpenseBudget invokes insightExpenseBudget operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by (any) budget.
        //
        // GET /v1/insight/expense/budget
        InsightExpenseBudget(ctx context.Context, params InsightExpenseBudgetParams) (InsightExpenseBudgetRes, error)
        // InsightExpenseCategory invokes insightExpenseCategory operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by (any) category.
        //
        // GET /v1/insight/expense/category
        InsightExpenseCategory(ctx context.Context, params InsightExpenseCategoryParams) (InsightExpenseCategoryRes, error)
        // InsightExpenseExpense invokes insightExpenseExpense operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by expense account.
        //
        // GET /v1/insight/expense/expense
        InsightExpenseExpense(ctx context.Context, params InsightExpenseExpenseParams) (InsightExpenseExpenseRes, error)
        // InsightExpenseNoBill invokes insightExpenseNoBill operation.
        //
        // This endpoint gives a summary of the expenses made by the user, including only expenses with no
        // bill.
        //
        // GET /v1/insight/expense/no-bill
        InsightExpenseNoBill(ctx context.Context, params InsightExpenseNoBillParams) (InsightExpenseNoBillRes, error)
        // InsightExpenseNoBudget invokes insightExpenseNoBudget operation.
        //
        // This endpoint gives a summary of the expenses made by the user, including only expenses with no
        // budget.
        //
        // GET /v1/insight/expense/no-budget
        InsightExpenseNoBudget(ctx context.Context, params InsightExpenseNoBudgetParams) (InsightExpenseNoBudgetRes, error)
        // InsightExpenseNoCategory invokes insightExpenseNoCategory operation.
        //
        // This endpoint gives a summary of the expenses made by the user, including only expenses with no
        // category.
        //
        // GET /v1/insight/expense/no-category
        InsightExpenseNoCategory(ctx context.Context, params InsightExpenseNoCategoryParams) (InsightExpenseNoCategoryRes, error)
        // InsightExpenseNoTag invokes insightExpenseNoTag operation.
        //
        // This endpoint gives a summary of the expenses made by the user, including only expenses with no
        // tag.
        //
        // GET /v1/insight/expense/no-tag
        InsightExpenseNoTag(ctx context.Context, params InsightExpenseNoTagParams) (InsightExpenseNoTagRes, error)
        // InsightExpenseTag invokes insightExpenseTag operation.
        //
        // This endpoint gives a summary of the expenses made by the user, grouped by (any) tag.
        //
        // GET /v1/insight/expense/tag
        InsightExpenseTag(ctx context.Context, params InsightExpenseTagParams) (InsightExpenseTagRes, error)
        // InsightExpenseTotal invokes insightExpenseTotal operation.
        //
        // This endpoint gives a sum of the total expenses made by the user.
        //
        // GET /v1/insight/expense/total
        InsightExpenseTotal(ctx context.Context, params InsightExpenseTotalParams) (InsightExpenseTotalRes, error)
        // InsightIncomeAsset invokes insightIncomeAsset operation.
        //
        // This endpoint gives a summary of the income received by the user, grouped by asset account.
        //
        // GET /v1/insight/income/asset
        InsightIncomeAsset(ctx context.Context, params InsightIncomeAssetParams) (InsightIncomeAssetRes, error)
        // InsightIncomeCategory invokes insightIncomeCategory operation.
        //
        // This endpoint gives a summary of the income received by the user, grouped by (any) category.
        //
        // GET /v1/insight/income/category
        InsightIncomeCategory(ctx context.Context, params InsightIncomeCategoryParams) (InsightIncomeCategoryRes, error)
        // InsightIncomeNoCategory invokes insightIncomeNoCategory operation.
        //
        // This endpoint gives a summary of the income received by the user, including only income with no
        // category.
        //
        // GET /v1/insight/income/no-category
        InsightIncomeNoCategory(ctx context.Context, params InsightIncomeNoCategoryParams) (InsightIncomeNoCategoryRes, error)
        // InsightIncomeNoTag invokes insightIncomeNoTag operation.
        //
        // This endpoint gives a summary of the income received by the user, including only income with no
        // tag.
        //
        // GET /v1/insight/income/no-tag
        InsightIncomeNoTag(ctx context.Context, params InsightIncomeNoTagParams) (InsightIncomeNoTagRes, error)
        // InsightIncomeRevenue invokes insightIncomeRevenue operation.
        //
        // This endpoint gives a summary of the income received by the user, grouped by revenue account.
        //
        // GET /v1/insight/income/revenue
        InsightIncomeRevenue(ctx context.Context, params InsightIncomeRevenueParams) (InsightIncomeRevenueRes, error)
        // InsightIncomeTag invokes insightIncomeTag operation.
        //
        // This endpoint gives a summary of the income received by the user, grouped by (any) tag.
        //
        // GET /v1/insight/income/tag
        InsightIncomeTag(ctx context.Context, params InsightIncomeTagParams) (InsightIncomeTagRes, error)
        // InsightIncomeTotal invokes insightIncomeTotal operation.
        //
        // This endpoint gives a sum of the total income received by the user.
        //
        // GET /v1/insight/income/total
        InsightIncomeTotal(ctx context.Context, params InsightIncomeTotalParams) (InsightIncomeTotalRes, error)
        // InsightTransferCategory invokes insightTransferCategory operation.
        //
        // This endpoint gives a summary of the transfers made by the user, grouped by (any) category.
        //
        // GET /v1/insight/transfer/category
        InsightTransferCategory(ctx context.Context, params InsightTransferCategoryParams) (InsightTransferCategoryRes, error)
        // InsightTransferNoCategory invokes insightTransferNoCategory operation.
        //
        // This endpoint gives a summary of the transfers made by the user, including only transfers with no
        // category.
        //
        // GET /v1/insight/transfer/no-category
        InsightTransferNoCategory(ctx context.Context, params InsightTransferNoCategoryParams) (InsightTransferNoCategoryRes, error)
        // InsightTransferNoTag invokes insightTransferNoTag operation.
        //
        // This endpoint gives a summary of the transfers made by the user, including only transfers with no
        // tag.
        //
        // GET /v1/insight/transfer/no-tag
        InsightTransferNoTag(ctx context.Context, params InsightTransferNoTagParams) (InsightTransferNoTagRes, error)
        // InsightTransferTag invokes insightTransferTag operation.
        //
        // This endpoint gives a summary of the transfers created by the user, grouped by (any) tag.
        //
        // GET /v1/insight/transfer/tag
        InsightTransferTag(ctx context.Context, params InsightTransferTagParams) (InsightTransferTagRes, error)
        // InsightTransferTotal invokes insightTransferTotal operation.
        //
        // This endpoint gives a sum of the total amount transfers made by the user.
        //
        // GET /v1/insight/transfer/total
        InsightTransferTotal(ctx context.Context, params InsightTransferTotalParams) (InsightTransferTotalRes, error)
        // InsightTransfers invokes insightTransfers operation.
        //
        // This endpoint gives a summary of the transfers made by the user, grouped by asset account or
        // lability.
        //
        // GET /v1/insight/transfer/asset
        InsightTransfers(ctx context.Context, params InsightTransfersParams) (InsightTransfersRes, error)
        // ListAccount invokes listAccount operation.
        //
        // This endpoint returns a list of all the accounts owned by the authenticated user.
        //
        // GET /v1/accounts
        ListAccount(ctx context.Context, params ListAccountParams) (ListAccountRes, error)
        // ListAccountByCurrency invokes listAccountByCurrency operation.
        //
        // List all accounts with this currency.
        //
        // GET /v1/currencies/{code}/accounts
        ListAccountByCurrency(ctx context.Context, params ListAccountByCurrencyParams) (ListAccountByCurrencyRes, error)
        // ListAttachment invokes listAttachment operation.
        //
        // This endpoint lists all attachments.
        //
        // GET /v1/attachments
        ListAttachment(ctx context.Context, params ListAttachmentParams) (ListAttachmentRes, error)
        // ListAttachmentByAccount invokes listAttachmentByAccount operation.
        //
        // Lists all attachments.
        //
        // GET /v1/accounts/{id}/attachments
        ListAttachmentByAccount(ctx context.Context, params ListAttachmentByAccountParams) (ListAttachmentByAccountRes, error)
        // ListAttachmentByBill invokes listAttachmentByBill operation.
        //
        // This endpoint will list all attachments linked to the bill.
        //
        // GET /v1/bills/{id}/attachments
        ListAttachmentByBill(ctx context.Context, params ListAttachmentByBillParams) (ListAttachmentByBillRes, error)
        // ListAttachmentByBudget invokes listAttachmentByBudget operation.
        //
        // Lists all attachments.
        //
        // GET /v1/budgets/{id}/attachments
        ListAttachmentByBudget(ctx context.Context, params ListAttachmentByBudgetParams) (ListAttachmentByBudgetRes, error)
        // ListAttachmentByCategory invokes listAttachmentByCategory operation.
        //
        // Lists all attachments.
        //
        // GET /v1/categories/{id}/attachments
        ListAttachmentByCategory(ctx context.Context, params ListAttachmentByCategoryParams) (ListAttachmentByCategoryRes, error)
        // ListAttachmentByPiggyBank invokes listAttachmentByPiggyBank operation.
        //
        // Lists all attachments.
        //
        // GET /v1/piggy-banks/{id}/attachments
        ListAttachmentByPiggyBank(ctx context.Context, params ListAttachmentByPiggyBankParams) (ListAttachmentByPiggyBankRes, error)
        // ListAttachmentByTag invokes listAttachmentByTag operation.
        //
        // Lists all attachments.
        //
        // GET /v1/tags/{tag}/attachments
        ListAttachmentByTag(ctx context.Context, params ListAttachmentByTagParams) (ListAttachmentByTagRes, error)
        // ListAttachmentByTransaction invokes listAttachmentByTransaction operation.
        //
        // Lists all attachments.
        //
        // GET /v1/transactions/{id}/attachments
        ListAttachmentByTransaction(ctx context.Context, params ListAttachmentByTransactionParams) (ListAttachmentByTransactionRes, error)
        // ListAvailableBudget invokes listAvailableBudget operation.
        //
        // Firefly III allows users to set the amount that is available to be budgeted in so-called
        // "available budgets". For example, the user could have 1200,- available to be divided during the
        // coming month. This amount is used on the /budgets page. This endpoint returns all of these amounts
        // and the periods for which they are set.
        //
        // GET /v1/available-budgets
        ListAvailableBudget(ctx context.Context, params ListAvailableBudgetParams) (ListAvailableBudgetRes, error)
        // ListAvailableBudgetByCurrency invokes listAvailableBudgetByCurrency operation.
        //
        // List all available budgets with this currency.
        //
        // GET /v1/currencies/{code}/available-budgets
        ListAvailableBudgetByCurrency(ctx context.Context, params ListAvailableBudgetByCurrencyParams) (ListAvailableBudgetByCurrencyRes, error)
        // ListBill invokes listBill operation.
        //
        // This endpoint will list all the user's bills.
        //
        // GET /v1/bills
        ListBill(ctx context.Context, params ListBillParams) (ListBillRes, error)
        // ListBillByCurrency invokes listBillByCurrency operation.
        //
        // List all bills with this currency.
        //
        // GET /v1/currencies/{code}/bills
        ListBillByCurrency(ctx context.Context, params ListBillByCurrencyParams) (ListBillByCurrencyRes, error)
        // ListBillByObjectGroup invokes listBillByObjectGroup operation.
        //
        // List all bills with this object group.
        //
        // GET /v1/object-groups/{id}/bills
        ListBillByObjectGroup(ctx context.Context, params ListBillByObjectGroupParams) (ListBillByObjectGroupRes, error)
        // ListBudget invokes listBudget operation.
        //
        // List all the budgets the user has made. If the start date and end date are submitted as well, the
        // "spent" array will be updated accordingly.
        //
        // GET /v1/budgets
        ListBudget(ctx context.Context, params ListBudgetParams) (ListBudgetRes, error)
        // ListBudgetLimit invokes listBudgetLimit operation.
        //
        // Get all budget limits for for this date range.
        //
        // GET /v1/budget-limits
        ListBudgetLimit(ctx context.Context, params ListBudgetLimitParams) (ListBudgetLimitRes, error)
        // ListBudgetLimitByBudget invokes listBudgetLimitByBudget operation.
        //
        // Get all budget limits for this budget and the money spent, and money left. You can limit the list
        // by submitting a date range as well. The "spent" array for each budget limit is NOT influenced by
        // the start and end date of your query, but by the start and end date of the budget limit itself.
        //
        // GET /v1/budgets/{id}/limits
        ListBudgetLimitByBudget(ctx context.Context, params ListBudgetLimitByBudgetParams) (ListBudgetLimitByBudgetRes, error)
        // ListBudgetLimitByCurrency invokes listBudgetLimitByCurrency operation.
        //
        // List all budget limits with this currency.
        //
        // GET /v1/currencies/{code}/budget_limits
        ListBudgetLimitByCurrency(ctx context.Context, params ListBudgetLimitByCurrencyParams) (ListBudgetLimitByCurrencyRes, error)
        // ListCategory invokes listCategory operation.
        //
        // List all categories.
        //
        // GET /v1/categories
        ListCategory(ctx context.Context, params ListCategoryParams) (ListCategoryRes, error)
        // ListCurrency invokes listCurrency operation.
        //
        // List all currencies.
        //
        // GET /v1/currencies
        ListCurrency(ctx context.Context, params ListCurrencyParams) (ListCurrencyRes, error)
        // ListEventByPiggyBank invokes listEventByPiggyBank operation.
        //
        // List all events linked to a piggy bank (adding and removing money).
        //
        // GET /v1/piggy-banks/{id}/events
        ListEventByPiggyBank(ctx context.Context, params ListEventByPiggyBankParams) (ListEventByPiggyBankRes, error)
        // ListEventByTransaction invokes listEventByTransaction operation.
        //
        // Lists all piggy bank events.
        //
        // GET /v1/transactions/{id}/piggy-bank-events
        ListEventByTransaction(ctx context.Context, params ListEventByTransactionParams) (ListEventByTransactionRes, error)
        // ListLinkType invokes listLinkType operation.
        //
        // List all the link types the system has. These include the default ones as well as any new ones.
        //
        // GET /v1/link-types
        ListLinkType(ctx context.Context, params ListLinkTypeParams) (ListLinkTypeRes, error)
        // ListLinksByJournal invokes listLinksByJournal operation.
        //
        // Lists all the transaction links for an individual journal (a split). Don't use the group ID, you
        // need the actual underlying journal (the split).
        //
        // GET /v1/transaction-journals/{id}/links
        ListLinksByJournal(ctx context.Context, params ListLinksByJournalParams) (ListLinksByJournalRes, error)
        // ListObjectGroups invokes listObjectGroups operation.
        //
        // List all oject groups.
        //
        // GET /v1/object-groups
        ListObjectGroups(ctx context.Context, params ListObjectGroupsParams) (ListObjectGroupsRes, error)
        // ListPiggyBank invokes listPiggyBank operation.
        //
        // List all piggy banks.
        //
        // GET /v1/piggy-banks
        ListPiggyBank(ctx context.Context, params ListPiggyBankParams) (ListPiggyBankRes, error)
        // ListPiggyBankByAccount invokes listPiggyBankByAccount operation.
        //
        // This endpoint returns a list of all the piggy banks connected to the account.
        //
        // GET /v1/accounts/{id}/piggy-banks
        ListPiggyBankByAccount(ctx context.Context, params ListPiggyBankByAccountParams) (ListPiggyBankByAccountRes, error)
        // ListPiggyBankByObjectGroup invokes listPiggyBankByObjectGroup operation.
        //
        // This endpoint returns a list of all the piggy banks connected to the object group.
        //
        // GET /v1/object-groups/{id}/piggy-banks
        ListPiggyBankByObjectGroup(ctx context.Context, params ListPiggyBankByObjectGroupParams) (ListPiggyBankByObjectGroupRes, error)
        // ListPreference invokes listPreference operation.
        //
        // List all of the preferences of the user.
        //
        // GET /v1/preferences
        ListPreference(ctx context.Context, params ListPreferenceParams) (ListPreferenceRes, error)
        // ListRecurrence invokes listRecurrence operation.
        //
        // List all recurring transactions.
        //
        // GET /v1/recurrences
        ListRecurrence(ctx context.Context, params ListRecurrenceParams) (ListRecurrenceRes, error)
        // ListRecurrenceByCurrency invokes listRecurrenceByCurrency operation.
        //
        // List all recurring transactions with this currency.
        //
        // GET /v1/currencies/{code}/recurrences
        ListRecurrenceByCurrency(ctx context.Context, params ListRecurrenceByCurrencyParams) (ListRecurrenceByCurrencyRes, error)
        // ListRule invokes listRule operation.
        //
        // List all rules.
        //
        // GET /v1/rules
        ListRule(ctx context.Context, params ListRuleParams) (ListRuleRes, error)
        // ListRuleByBill invokes listRuleByBill operation.
        //
        // This endpoint will list all rules that have an action to set the bill to this bill.
        //
        // GET /v1/bills/{id}/rules
        ListRuleByBill(ctx context.Context, params ListRuleByBillParams) (ListRuleByBillRes, error)
        // ListRuleByCurrency invokes listRuleByCurrency operation.
        //
        // List all rules with this currency.
        //
        // GET /v1/currencies/{code}/rules
        ListRuleByCurrency(ctx context.Context, params ListRuleByCurrencyParams) (ListRuleByCurrencyRes, error)
        // ListRuleByGroup invokes listRuleByGroup operation.
        //
        // List rules in this rule group.
        //
        // GET /v1/rule-groups/{id}/rules
        ListRuleByGroup(ctx context.Context, params ListRuleByGroupParams) (ListRuleByGroupRes, error)
        // ListRuleGroup invokes listRuleGroup operation.
        //
        // List all rule groups.
        //
        // GET /v1/rule-groups
        ListRuleGroup(ctx context.Context, params ListRuleGroupParams) (ListRuleGroupRes, error)
        // ListTag invokes listTag operation.
        //
        // List all of the user's tags.
        //
        // GET /v1/tags
        ListTag(ctx context.Context, params ListTagParams) (ListTagRes, error)
        // ListTransaction invokes listTransaction operation.
        //
        // List all the user's transactions.
        //
        // GET /v1/transactions
        ListTransaction(ctx context.Context, params ListTransactionParams) (ListTransactionRes, error)
        // ListTransactionByAccount invokes listTransactionByAccount operation.
        //
        // This endpoint returns a list of all the transactions connected to the account.
        //
        // GET /v1/accounts/{id}/transactions
        ListTransactionByAccount(ctx context.Context, params ListTransactionByAccountParams) (ListTransactionByAccountRes, error)
        // ListTransactionByBill invokes listTransactionByBill operation.
        //
        // This endpoint will list all transactions linked to this bill.
        //
        // GET /v1/bills/{id}/transactions
        ListTransactionByBill(ctx context.Context, params ListTransactionByBillParams) (ListTransactionByBillRes, error)
        // ListTransactionByBudget invokes listTransactionByBudget operation.
        //
        // Get all transactions linked to a budget, possibly limited by start and end.
        //
        // GET /v1/budgets/{id}/transactions
        ListTransactionByBudget(ctx context.Context, params ListTransactionByBudgetParams) (ListTransactionByBudgetRes, error)
        // ListTransactionByBudgetLimit invokes listTransactionByBudgetLimit operation.
        //
        // List all the transactions within one budget limit. The start and end date are dictated by the
        // budget limit.
        //
        // GET /v1/budgets/{id}/limits/{limitId}/transactions
        ListTransactionByBudgetLimit(ctx context.Context, params ListTransactionByBudgetLimitParams) (ListTransactionByBudgetLimitRes, error)
        // ListTransactionByCategory invokes listTransactionByCategory operation.
        //
        // List all transactions in a category, optionally limited to the date ranges specified.
        //
        // GET /v1/categories/{id}/transactions
        ListTransactionByCategory(ctx context.Context, params ListTransactionByCategoryParams) (ListTransactionByCategoryRes, error)
        // ListTransactionByCurrency invokes listTransactionByCurrency operation.
        //
        // List all transactions with this currency.
        //
        // GET /v1/currencies/{code}/transactions
        ListTransactionByCurrency(ctx context.Context, params ListTransactionByCurrencyParams) (ListTransactionByCurrencyRes, error)
        // ListTransactionByLinkType invokes listTransactionByLinkType operation.
        //
        // List all transactions under this link type, both the inward and outward transactions.
        //
        // GET /v1/link-types/{id}/transactions
        ListTransactionByLinkType(ctx context.Context, params ListTransactionByLinkTypeParams) (ListTransactionByLinkTypeRes, error)
        // ListTransactionByRecurrence invokes listTransactionByRecurrence operation.
        //
        // List all transactions created by a recurring transaction, optionally limited to the date ranges
        // specified.
        //
        // GET /v1/recurrences/{id}/transactions
        ListTransactionByRecurrence(ctx context.Context, params ListTransactionByRecurrenceParams) (ListTransactionByRecurrenceRes, error)
        // ListTransactionByTag invokes listTransactionByTag operation.
        //
        // List all transactions with this tag.
        //
        // GET /v1/tags/{tag}/transactions
        ListTransactionByTag(ctx context.Context, params ListTransactionByTagParams) (ListTransactionByTagRes, error)
        // ListTransactionLink invokes listTransactionLink operation.
        //
        // List all the transaction links.
        //
        // GET /v1/transaction-links
        ListTransactionLink(ctx context.Context, params ListTransactionLinkParams) (ListTransactionLinkRes, error)
        // ListUser invokes listUser operation.
        //
        // List all the users in this instance of Firefly III.
        //
        // GET /v1/users
        ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error)
        // ListWebhook invokes listWebhook operation.
        //
        // List all the user's webhooks.
        //
        // GET /v1/webhooks
        ListWebhook(ctx context.Context, params ListWebhookParams) (ListWebhookRes, error)
        // PurgeData invokes purgeData operation.
        //
        // A call to this endpoint purges all previously deleted data. Use it with care and always with user
        // permission.
        // The demo user is incapable of using this endpoint.
        //
        // DELETE /v1/data/purge
        PurgeData(ctx context.Context, params PurgeDataParams) (PurgeDataRes, error)
        // SearchAccounts invokes searchAccounts operation.
        //
        // Search for accounts.
        //
        // GET /v1/search/accounts
        SearchAccounts(ctx context.Context, params SearchAccountsParams) (SearchAccountsRes, error)
        // SearchTransactions invokes searchTransactions operation.
        //
        // Searches through the users transactions.
        //
        // GET /v1/search/transactions
        SearchTransactions(ctx context.Context, params SearchTransactionsParams) (SearchTransactionsRes, error)
        // SetConfiguration invokes setConfiguration operation.
        //
        // Set a single configuration value. Not all configuration values can be updated so the list of
        // accepted configuration variables is small.
        //
        // PUT /v1/configuration/{name}
        SetConfiguration(ctx context.Context, request *ConfigurationUpdate, params SetConfigurationParams) (SetConfigurationRes, error)
        // StoreAccount invokes storeAccount operation.
        //
        // Creates a new account. The data required can be submitted as a JSON body or as a list of
        // parameters (in key=value pairs, like a webform).
        //
        // POST /v1/accounts
        StoreAccount(ctx context.Context, request *AccountStore, params StoreAccountParams) (StoreAccountRes, error)
        // StoreAttachment invokes storeAttachment operation.
        //
        // Creates a new attachment. The data required can be submitted as a JSON body or as a list of
        // parameters. You cannot use this endpoint to upload the actual file data (see below). This endpoint
        // only creates the attachment object.
        //
        // POST /v1/attachments
        StoreAttachment(ctx context.Context, request *AttachmentStore, params StoreAttachmentParams) (StoreAttachmentRes, error)
        // StoreBill invokes storeBill operation.
        //
        // Creates a new bill. The data required can be submitted as a JSON body or as a list of parameters.
        //
        // POST /v1/bills
        StoreBill(ctx context.Context, request *BillStore, params StoreBillParams) (StoreBillRes, error)
        // StoreBudget invokes storeBudget operation.
        //
        // Creates a new budget. The data required can be submitted as a JSON body or as a list of parameters.
        //
        // POST /v1/budgets
        StoreBudget(ctx context.Context, request *BudgetStore, params StoreBudgetParams) (StoreBudgetRes, error)
        // StoreBudgetLimit invokes storeBudgetLimit operation.
        //
        // Store a new budget limit under this budget.
        //
        // POST /v1/budgets/{id}/limits
        StoreBudgetLimit(ctx context.Context, request *BudgetLimitStore, params StoreBudgetLimitParams) (StoreBudgetLimitRes, error)
        // StoreCategory invokes storeCategory operation.
        //
        // Creates a new category. The data required can be submitted as a JSON body or as a list of
        // parameters.
        //
        // POST /v1/categories
        StoreCategory(ctx context.Context, request *Category, params StoreCategoryParams) (StoreCategoryRes, error)
        // StoreCurrency invokes storeCurrency operation.
        //
        // Creates a new currency. The data required can be submitted as a JSON body or as a list of
        // parameters.
        //
        // POST /v1/currencies
        StoreCurrency(ctx context.Context, request *CurrencyStore, params StoreCurrencyParams) (StoreCurrencyRes, error)
        // StoreLinkType invokes storeLinkType operation.
        //
        // Creates a new link type. The data required can be submitted as a JSON body or as a list of
        // parameters (in key=value pairs, like a webform).
        //
        // POST /v1/link-types
        StoreLinkType(ctx context.Context, request *LinkType, params StoreLinkTypeParams) (StoreLinkTypeRes, error)
        // StorePiggyBank invokes storePiggyBank operation.
        //
        // Creates a new piggy bank. The data required can be submitted as a JSON body or as a list of
        // parameters.
        //
        // POST /v1/piggy-banks
        StorePiggyBank(ctx context.Context, request *PiggyBankStore, params StorePiggyBankParams) (StorePiggyBankRes, error)
        // StorePreference invokes storePreference operation.
        //
        // This endpoint creates a new preference. The name and data are free-format, and entirely up to you.
        // If the preference is not used in Firefly III itself it may not be configurable through the user
        // interface, but you can use this endpoint to persist custom data for your own app.
        //
        // POST /v1/preferences
        StorePreference(ctx context.Context, request *Preference, params StorePreferenceParams) (StorePreferenceRes, error)
        // StoreRecurrence invokes storeRecurrence operation.
        //
        // Creates a new recurring transaction. The data required can be submitted as a JSON body or as a
        // list of parameters.
        //
        // POST /v1/recurrences
        StoreRecurrence(ctx context.Context, request *RecurrenceStore, params StoreRecurrenceParams) (StoreRecurrenceRes, error)
        // StoreRule invokes storeRule operation.
        //
        // Creates a new rule. The data required can be submitted as a JSON body or as a list of parameters.
        //
        // POST /v1/rules
        StoreRule(ctx context.Context, request *RuleStore, params StoreRuleParams) (StoreRuleRes, error)
        // StoreRuleGroup invokes storeRuleGroup operation.
        //
        // Creates a new rule group. The data required can be submitted as a JSON body or as a list of
        // parameters.
        //
        // POST /v1/rule-groups
        StoreRuleGroup(ctx context.Context, request *RuleGroupStore, params StoreRuleGroupParams) (StoreRuleGroupRes, error)
        // StoreTag invokes storeTag operation.
        //
        // Creates a new tag. The data required can be submitted as a JSON body or as a list of parameters.
        //
        // POST /v1/tags
        StoreTag(ctx context.Context, request *TagModelStore, params StoreTagParams) (StoreTagRes, error)
        // StoreTransaction invokes storeTransaction operation.
        //
        // Creates a new transaction. The data required can be submitted as a JSON body or as a list of
        // parameters.
        //
        // POST /v1/transactions
        StoreTransaction(ctx context.Context, request *TransactionStore, params StoreTransactionParams) (StoreTransactionRes, error)
        // StoreTransactionLink invokes storeTransactionLink operation.
        //
        // Store a new link between two transactions. For this end point you need the journal_id from a
        // transaction.
        //
        // POST /v1/transaction-links
        StoreTransactionLink(ctx context.Context, request *TransactionLinkStore, params StoreTransactionLinkParams) (StoreTransactionLinkRes, error)
        // StoreUser invokes storeUser operation.
        //
        // Creates a new user. The data required can be submitted as a JSON body or as a list of parameters.
        // The user will be given a random password, which they can reset using the "forgot password"
        // function.
        //
        // POST /v1/users
        StoreUser(ctx context.Context, request *User, params StoreUserParams) (StoreUserRes, error)
        // StoreWebhook invokes storeWebhook operation.
        //
        // Creates a new webhook. The data required can be submitted as a JSON body or as a list of
        // parameters. The webhook will be given a random secret.
        //
        // POST /v1/webhooks
        StoreWebhook(ctx context.Context, request *WebhookStore, params StoreWebhookParams) (StoreWebhookRes, error)
        // SubmitWebook invokes submitWebook operation.
        //
        // This endpoint will submit any open messages for this webhook. This is an asynchronous operation,
        // so you can't see the result. Refresh the webhook message and/or the webhook message attempts to
        // see the results. This may take some time if the webhook receiver is slow.
        //
        // POST /v1/webhooks/{id}/submit
        SubmitWebook(ctx context.Context, params SubmitWebookParams) (SubmitWebookRes, error)
        // TestRule invokes testRule operation.
        //
        // Test which transactions would be hit by the rule. No changes will be made. Limit the result if you
        // want to.
        //
        // GET /v1/rules/{id}/test
        TestRule(ctx context.Context, params TestRuleParams) (TestRuleRes, error)
        // TestRuleGroup invokes testRuleGroup operation.
        //
        // Test which transactions would be hit by the rule group. No changes will be made. Limit the result
        // if you want to.
        //
        // GET /v1/rule-groups/{id}/test
        TestRuleGroup(ctx context.Context, params TestRuleGroupParams) (TestRuleGroupRes, error)
        // UpdateAccount invokes updateAccount operation.
        //
        // Used to update a single account. All fields that are not submitted will be cleared (set to NULL).
        // The model will tell you which fields are mandatory.
        //
        // PUT /v1/accounts/{id}
        UpdateAccount(ctx context.Context, request *AccountUpdate, params UpdateAccountParams) (UpdateAccountRes, error)
        // UpdateAttachment invokes updateAttachment operation.
        //
        // Update the meta data for an existing attachment. This endpoint does not allow you to upload or
        // download data. For that, see below.
        //
        // PUT /v1/attachments/{id}
        UpdateAttachment(ctx context.Context, request *AttachmentUpdate, params UpdateAttachmentParams) (UpdateAttachmentRes, error)
        // UpdateBill invokes updateBill operation.
        //
        // Update existing bill.
        //
        // PUT /v1/bills/{id}
        UpdateBill(ctx context.Context, request *BillUpdate, params UpdateBillParams) (UpdateBillRes, error)
        // UpdateBudget invokes updateBudget operation.
        //
        // Update existing budget. This endpoint cannot be used to set budget amount limits.
        //
        // PUT /v1/budgets/{id}
        UpdateBudget(ctx context.Context, request *BudgetUpdate, params UpdateBudgetParams) (UpdateBudgetRes, error)
        // UpdateBudgetLimit invokes updateBudgetLimit operation.
        //
        // Update existing budget limit.
        //
        // PUT /v1/budgets/{id}/limits/{limitId}
        UpdateBudgetLimit(ctx context.Context, request *BudgetLimit, params UpdateBudgetLimitParams) (UpdateBudgetLimitRes, error)
        // UpdateCategory invokes updateCategory operation.
        //
        // Update existing category.
        //
        // PUT /v1/categories/{id}
        UpdateCategory(ctx context.Context, request *CategoryUpdate, params UpdateCategoryParams) (UpdateCategoryRes, error)
        // UpdateCurrency invokes updateCurrency operation.
        //
        // Update existing currency.
        //
        // PUT /v1/currencies/{code}
        UpdateCurrency(ctx context.Context, request *CurrencyUpdate, params UpdateCurrencyParams) (UpdateCurrencyRes, error)
        // UpdateLinkType invokes updateLinkType operation.
        //
        // Used to update a single link type. All fields that are not submitted will be cleared (set to NULL).
        //  The model will tell you which fields are mandatory. You cannot update some of the system provided
        // link types, indicated by the editable=false flag when you list it.
        //
        // PUT /v1/link-types/{id}
        UpdateLinkType(ctx context.Context, request *LinkTypeUpdate, params UpdateLinkTypeParams) (UpdateLinkTypeRes, error)
        // UpdateObjectGroup invokes updateObjectGroup operation.
        //
        // Update existing object group.
        //
        // PUT /v1/object-groups/{id}
        UpdateObjectGroup(ctx context.Context, request *ObjectGroupUpdate, params UpdateObjectGroupParams) (UpdateObjectGroupRes, error)
        // UpdatePiggyBank invokes updatePiggyBank operation.
        //
        // Update existing piggy bank.
        //
        // PUT /v1/piggy-banks/{id}
        UpdatePiggyBank(ctx context.Context, request *PiggyBankUpdate, params UpdatePiggyBankParams) (UpdatePiggyBankRes, error)
        // UpdatePreference invokes updatePreference operation.
        //
        // Update a user's preference.
        //
        // PUT /v1/preferences/{name}
        UpdatePreference(ctx context.Context, request *PreferenceUpdate, params UpdatePreferenceParams) (UpdatePreferenceRes, error)
        // UpdateRecurrence invokes updateRecurrence operation.
        //
        // Update existing recurring transaction.
        //
        // PUT /v1/recurrences/{id}
        UpdateRecurrence(ctx context.Context, request *RecurrenceUpdate, params UpdateRecurrenceParams) (UpdateRecurrenceRes, error)
        // UpdateRule invokes updateRule operation.
        //
        // Update existing rule.
        //
        // PUT /v1/rules/{id}
        UpdateRule(ctx context.Context, request *RuleUpdate, params UpdateRuleParams) (UpdateRuleRes, error)
        // UpdateRuleGroup invokes updateRuleGroup operation.
        //
        // Update existing rule group.
        //
        // PUT /v1/rule-groups/{id}
        UpdateRuleGroup(ctx context.Context, request *RuleGroupUpdate, params UpdateRuleGroupParams) (UpdateRuleGroupRes, error)
        // UpdateTag invokes updateTag operation.
        //
        // Update existing tag.
        //
        // PUT /v1/tags/{tag}
        UpdateTag(ctx context.Context, request *TagModelUpdate, params UpdateTagParams) (UpdateTagRes, error)
        // UpdateTransaction invokes updateTransaction operation.
        //
        // Update an existing transaction.
        //
        // PUT /v1/transactions/{id}
        UpdateTransaction(ctx context.Context, request *TransactionUpdate, params UpdateTransactionParams) (UpdateTransactionRes, error)
        // UpdateTransactionLink invokes updateTransactionLink operation.
        //
        // Used to update a single existing link.
        //
        // PUT /v1/transaction-links/{id}
        UpdateTransactionLink(ctx context.Context, request *TransactionLinkUpdate, params UpdateTransactionLinkParams) (UpdateTransactionLinkRes, error)
        // UpdateUser invokes updateUser operation.
        //
        // Update existing user.
        //
        // PUT /v1/users/{id}
        UpdateUser(ctx context.Context, request *User, params UpdateUserParams) (UpdateUserRes, error)
        // UpdateWebhook invokes updateWebhook operation.
        //
        // Update an existing webhook's information. If you wish to reset the secret, submit any value as the
        // "secret". Firefly III will take this as a hint and reset the secret of the webhook.
        //
        // PUT /v1/webhooks/{id}
        UpdateWebhook(ctx context.Context, request *WebhookUpdate, params UpdateWebhookParams) (UpdateWebhookRes, error)
        // UploadAttachment invokes uploadAttachment operation.
        //
        // Use this endpoint to upload (and possible overwrite) the file contents of an attachment. Simply
        // put the entire file in the body as binary data.
        //
        // POST /v1/attachments/{id}/upload
        UploadAttachment(ctx context.Context, request UploadAttachmentReq, params UploadAttachmentParams) (UploadAttachmentRes, error)
}

// Client implements OAS client.
type Client struct {
        serverURL *url.URL
        sec       SecuritySource
        baseClient
}

func trimTrailingSlashes(u *url.URL) {
        u.Path = strings.TrimRight(u.Path, "/")
        u.RawPath = strings.TrimRight(u.RawPath, "/")
}

// NewClient initializes new Client defined by OAS.
func NewClient(serverURL string, sec SecuritySource, opts ...ClientOption) (*Client, error) {
        u, err := url.Parse(serverURL)
        if err != nil {
                return nil, err
        }
        trimTrailingSlashes(u)

        c, err := newClientConfig(opts...).baseClient()
        if err != nil {
                return nil, err
        }
        return &Client{
                serverURL:  u,
                sec:        sec,
                baseClient: c,
        }, nil
}

type serverURLKey struct{}

// WithServerURL sets context key to override server URL.
func WithServerURL(ctx context.Context, u *url.URL) context.Context {
        return context.WithValue(ctx, serverURLKey{}, u)
}

func (c *Client) requestURL(ctx context.Context) *url.URL {
        u, ok := ctx.Value(serverURLKey{}).(*url.URL)
        if !ok {
                return c.serverURL
        }
        return u
}

// BulkUpdateTransactions invokes bulkUpdateTransactions operation.
//
// Allows you to update transactions in bulk.
//
// POST /v1/data/bulk/transactions
func (c *Client) BulkUpdateTransactions(ctx context.Context, params BulkUpdateTransactionsParams) (BulkUpdateTransactionsRes, error) {
        res, err := c.sendBulkUpdateTransactions(ctx, params)
        return res, err
}

func (c *Client) sendBulkUpdateTransactions(ctx context.Context, params BulkUpdateTransactionsParams) (res BulkUpdateTransactionsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("bulkUpdateTransactions"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/data/bulk/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "BulkUpdateTransactions",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/bulk/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.StringToString(params.Query))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "BulkUpdateTransactions", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeBulkUpdateTransactionsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DefaultCurrency invokes defaultCurrency operation.
//
// Make this currency the default currency for the user. If the currency is not enabled, it will be
// enabled as well.
//
// POST /v1/currencies/{code}/default
func (c *Client) DefaultCurrency(ctx context.Context, params DefaultCurrencyParams) (DefaultCurrencyRes, error) {
        res, err := c.sendDefaultCurrency(ctx, params)
        return res, err
}

func (c *Client) sendDefaultCurrency(ctx context.Context, params DefaultCurrencyParams) (res DefaultCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("defaultCurrency"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/default"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DefaultCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/default"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DefaultCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDefaultCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteAccount invokes deleteAccount operation.
//
// Will permanently delete an account. Any associated transactions and piggy banks are ALSO deleted.
// Cannot be recovered from.
//
// DELETE /v1/accounts/{id}
func (c *Client) DeleteAccount(ctx context.Context, params DeleteAccountParams) (DeleteAccountRes, error) {
        res, err := c.sendDeleteAccount(ctx, params)
        return res, err
}

func (c *Client) sendDeleteAccount(ctx context.Context, params DeleteAccountParams) (res DeleteAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteAccount"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteAttachment invokes deleteAttachment operation.
//
// With this endpoint you delete an attachment, including any stored file data.
//
// DELETE /v1/attachments/{id}
func (c *Client) DeleteAttachment(ctx context.Context, params DeleteAttachmentParams) (DeleteAttachmentRes, error) {
        res, err := c.sendDeleteAttachment(ctx, params)
        return res, err
}

func (c *Client) sendDeleteAttachment(ctx context.Context, params DeleteAttachmentParams) (res DeleteAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteAttachment"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/attachments/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/attachments/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteBill invokes deleteBill operation.
//
// Delete a bill. This will not delete any associated rules. Will not remove associated transactions.
// WILL remove all associated attachments.
//
// DELETE /v1/bills/{id}
func (c *Client) DeleteBill(ctx context.Context, params DeleteBillParams) (DeleteBillRes, error) {
        res, err := c.sendDeleteBill(ctx, params)
        return res, err
}

func (c *Client) sendDeleteBill(ctx context.Context, params DeleteBillParams) (res DeleteBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteBill"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteBudget invokes deleteBudget operation.
//
// Delete a budget. Transactions will not be deleted.
//
// DELETE /v1/budgets/{id}
func (c *Client) DeleteBudget(ctx context.Context, params DeleteBudgetParams) (DeleteBudgetRes, error) {
        res, err := c.sendDeleteBudget(ctx, params)
        return res, err
}

func (c *Client) sendDeleteBudget(ctx context.Context, params DeleteBudgetParams) (res DeleteBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteBudget"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteBudgetLimit invokes deleteBudgetLimit operation.
//
// Delete a budget limit.
//
// DELETE /v1/budgets/{id}/limits/{limitId}
func (c *Client) DeleteBudgetLimit(ctx context.Context, params DeleteBudgetLimitParams) (DeleteBudgetLimitRes, error) {
        res, err := c.sendDeleteBudgetLimit(ctx, params)
        return res, err
}

func (c *Client) sendDeleteBudgetLimit(ctx context.Context, params DeleteBudgetLimitParams) (res DeleteBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteBudgetLimit"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits/{limitId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [4]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits/"
        {
                // Encode "limitId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "limitId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.LimitId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteCategory invokes deleteCategory operation.
//
// Delete a category. Transactions will not be removed.
//
// DELETE /v1/categories/{id}
func (c *Client) DeleteCategory(ctx context.Context, params DeleteCategoryParams) (DeleteCategoryRes, error) {
        res, err := c.sendDeleteCategory(ctx, params)
        return res, err
}

func (c *Client) sendDeleteCategory(ctx context.Context, params DeleteCategoryParams) (res DeleteCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteCategory"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/categories/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/categories/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteCurrency invokes deleteCurrency operation.
//
// Delete a currency.
//
// DELETE /v1/currencies/{code}
func (c *Client) DeleteCurrency(ctx context.Context, params DeleteCurrencyParams) (DeleteCurrencyRes, error) {
        res, err := c.sendDeleteCurrency(ctx, params)
        return res, err
}

func (c *Client) sendDeleteCurrency(ctx context.Context, params DeleteCurrencyParams) (res DeleteCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteCurrency"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteLinkType invokes deleteLinkType operation.
//
// Will permanently delete a link type. The links between transactions will be removed. The
// transactions themselves remain. You cannot delete some of the system provided link types,
// indicated by the editable=false flag when you list it.
//
// DELETE /v1/link-types/{id}
func (c *Client) DeleteLinkType(ctx context.Context, params DeleteLinkTypeParams) (DeleteLinkTypeRes, error) {
        res, err := c.sendDeleteLinkType(ctx, params)
        return res, err
}

func (c *Client) sendDeleteLinkType(ctx context.Context, params DeleteLinkTypeParams) (res DeleteLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteLinkType"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/link-types/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/link-types/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteObjectGroup invokes deleteObjectGroup operation.
//
// Delete a object group.
//
// DELETE /v1/object-groups/{id}
func (c *Client) DeleteObjectGroup(ctx context.Context, params DeleteObjectGroupParams) (DeleteObjectGroupRes, error) {
        res, err := c.sendDeleteObjectGroup(ctx, params)
        return res, err
}

func (c *Client) sendDeleteObjectGroup(ctx context.Context, params DeleteObjectGroupParams) (res DeleteObjectGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteObjectGroup"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/object-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteObjectGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/object-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteObjectGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteObjectGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeletePiggyBank invokes deletePiggyBank operation.
//
// Delete a piggy bank.
//
// DELETE /v1/piggy-banks/{id}
func (c *Client) DeletePiggyBank(ctx context.Context, params DeletePiggyBankParams) (DeletePiggyBankRes, error) {
        res, err := c.sendDeletePiggyBank(ctx, params)
        return res, err
}

func (c *Client) sendDeletePiggyBank(ctx context.Context, params DeletePiggyBankParams) (res DeletePiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deletePiggyBank"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeletePiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/piggy-banks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeletePiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeletePiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteRecurrence invokes deleteRecurrence operation.
//
// Delete a recurring transaction. Transactions created by the recurring transaction will not be
// deleted.
//
// DELETE /v1/recurrences/{id}
func (c *Client) DeleteRecurrence(ctx context.Context, params DeleteRecurrenceParams) (DeleteRecurrenceRes, error) {
        res, err := c.sendDeleteRecurrence(ctx, params)
        return res, err
}

func (c *Client) sendDeleteRecurrence(ctx context.Context, params DeleteRecurrenceParams) (res DeleteRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteRecurrence"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/recurrences/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/recurrences/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteRule invokes deleteRule operation.
//
// Delete an rule.
//
// DELETE /v1/rules/{id}
func (c *Client) DeleteRule(ctx context.Context, params DeleteRuleParams) (DeleteRuleRes, error) {
        res, err := c.sendDeleteRule(ctx, params)
        return res, err
}

func (c *Client) sendDeleteRule(ctx context.Context, params DeleteRuleParams) (res DeleteRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteRule"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/rules/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rules/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteRuleGroup invokes deleteRuleGroup operation.
//
// Delete a rule group.
//
// DELETE /v1/rule-groups/{id}
func (c *Client) DeleteRuleGroup(ctx context.Context, params DeleteRuleGroupParams) (DeleteRuleGroupRes, error) {
        res, err := c.sendDeleteRuleGroup(ctx, params)
        return res, err
}

func (c *Client) sendDeleteRuleGroup(ctx context.Context, params DeleteRuleGroupParams) (res DeleteRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteRuleGroup"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteTag invokes deleteTag operation.
//
// Delete an tag.
//
// DELETE /v1/tags/{tag}
func (c *Client) DeleteTag(ctx context.Context, params DeleteTagParams) (DeleteTagRes, error) {
        res, err := c.sendDeleteTag(ctx, params)
        return res, err
}

func (c *Client) sendDeleteTag(ctx context.Context, params DeleteTagParams) (res DeleteTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteTag"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/tags/{tag}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/tags/"
        {
                // Encode "tag" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "tag",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Tag))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteTransaction invokes deleteTransaction operation.
//
// Delete a transaction.
//
// DELETE /v1/transactions/{id}
func (c *Client) DeleteTransaction(ctx context.Context, params DeleteTransactionParams) (DeleteTransactionRes, error) {
        res, err := c.sendDeleteTransaction(ctx, params)
        return res, err
}

func (c *Client) sendDeleteTransaction(ctx context.Context, params DeleteTransactionParams) (res DeleteTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteTransaction"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/transactions/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transactions/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteTransactionJournal invokes deleteTransactionJournal operation.
//
// Delete an individual journal (split) from a transaction.
//
// DELETE /v1/transaction-journals/{id}
func (c *Client) DeleteTransactionJournal(ctx context.Context, params DeleteTransactionJournalParams) (DeleteTransactionJournalRes, error) {
        res, err := c.sendDeleteTransactionJournal(ctx, params)
        return res, err
}

func (c *Client) sendDeleteTransactionJournal(ctx context.Context, params DeleteTransactionJournalParams) (res DeleteTransactionJournalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteTransactionJournal"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/transaction-journals/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteTransactionJournal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transaction-journals/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteTransactionJournal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteTransactionJournalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteTransactionLink invokes deleteTransactionLink operation.
//
// Will permanently delete link. Transactions remain.
//
// DELETE /v1/transaction-links/{id}
func (c *Client) DeleteTransactionLink(ctx context.Context, params DeleteTransactionLinkParams) (DeleteTransactionLinkRes, error) {
        res, err := c.sendDeleteTransactionLink(ctx, params)
        return res, err
}

func (c *Client) sendDeleteTransactionLink(ctx context.Context, params DeleteTransactionLinkParams) (res DeleteTransactionLinkRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteTransactionLink"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/transaction-links/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteTransactionLink",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transaction-links/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteTransactionLink", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteTransactionLinkResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteUser invokes deleteUser operation.
//
// Delete a user. You cannot delete the user you're authenticated with. This cannot be undone. Be
// careful!.
//
// DELETE /v1/users/{id}
func (c *Client) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) {
        res, err := c.sendDeleteUser(ctx, params)
        return res, err
}

func (c *Client) sendDeleteUser(ctx context.Context, params DeleteUserParams) (res DeleteUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteUser"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/users/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/users/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteWebhook invokes deleteWebhook operation.
//
// Delete a webhook.
//
// DELETE /v1/webhooks/{id}
func (c *Client) DeleteWebhook(ctx context.Context, params DeleteWebhookParams) (DeleteWebhookRes, error) {
        res, err := c.sendDeleteWebhook(ctx, params)
        return res, err
}

func (c *Client) sendDeleteWebhook(ctx context.Context, params DeleteWebhookParams) (res DeleteWebhookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteWebhook"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteWebhook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteWebhook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteWebhookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteWebhookMessage invokes deleteWebhookMessage operation.
//
// Delete a webhook message. Any time a webhook is triggered the message is stored before it's sent.
// You can delete them before or after sending.
//
// DELETE /v1/webhooks/{id}/messages/{messageId}
func (c *Client) DeleteWebhookMessage(ctx context.Context, params DeleteWebhookMessageParams) (DeleteWebhookMessageRes, error) {
        res, err := c.sendDeleteWebhookMessage(ctx, params)
        return res, err
}

func (c *Client) sendDeleteWebhookMessage(ctx context.Context, params DeleteWebhookMessageParams) (res DeleteWebhookMessageRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteWebhookMessage"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages/{messageId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteWebhookMessage",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [4]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages/"
        {
                // Encode "messageId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "messageId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.MessageId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteWebhookMessage", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteWebhookMessageResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DeleteWebhookMessageAttempt invokes deleteWebhookMessageAttempt operation.
//
// Delete a webhook message attempt. If you delete all attempts for a webhook message, Firefly III
// will (once again) assume all is well with the webhook message and will try to send it again.
//
// DELETE /v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}
func (c *Client) DeleteWebhookMessageAttempt(ctx context.Context, params DeleteWebhookMessageAttemptParams) (DeleteWebhookMessageAttemptRes, error) {
        res, err := c.sendDeleteWebhookMessageAttempt(ctx, params)
        return res, err
}

func (c *Client) sendDeleteWebhookMessageAttempt(ctx context.Context, params DeleteWebhookMessageAttemptParams) (res DeleteWebhookMessageAttemptRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("deleteWebhookMessageAttempt"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DeleteWebhookMessageAttempt",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [6]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages/"
        {
                // Encode "messageId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "messageId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.MessageId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        pathParts[4] = "/attempts/"
        {
                // Encode "attemptId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "attemptId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.AttemptId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[5] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DeleteWebhookMessageAttempt", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDeleteWebhookMessageAttemptResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DestroyData invokes destroyData operation.
//
// A call to this endpoint deletes the requested data type. Use it with care and always with user
// permission.
// The demo user is incapable of using this endpoint.
//
// DELETE /v1/data/destroy
func (c *Client) DestroyData(ctx context.Context, params DestroyDataParams) (DestroyDataRes, error) {
        res, err := c.sendDestroyData(ctx, params)
        return res, err
}

func (c *Client) sendDestroyData(ctx context.Context, params DestroyDataParams) (res DestroyDataRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("destroyData"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/data/destroy"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DestroyData",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/destroy"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "objects" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "objects",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.StringToString(string(params.Objects)))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DestroyData", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDestroyDataResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DisableCurrency invokes disableCurrency operation.
//
// Disable a currency.
//
// POST /v1/currencies/{code}/disable
func (c *Client) DisableCurrency(ctx context.Context, params DisableCurrencyParams) (DisableCurrencyRes, error) {
        res, err := c.sendDisableCurrency(ctx, params)
        return res, err
}

func (c *Client) sendDisableCurrency(ctx context.Context, params DisableCurrencyParams) (res DisableCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("disableCurrency"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/disable"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DisableCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/disable"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DisableCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDisableCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// DownloadAttachment invokes downloadAttachment operation.
//
// This endpoint allows you to download the binary content of a transaction. It will be sent to you
// as a download, using the content type "application/octet-stream" and content disposition
// "attachment; filename=example.pdf".
//
// GET /v1/attachments/{id}/download
func (c *Client) DownloadAttachment(ctx context.Context, params DownloadAttachmentParams) (DownloadAttachmentRes, error) {
        res, err := c.sendDownloadAttachment(ctx, params)
        return res, err
}

func (c *Client) sendDownloadAttachment(ctx context.Context, params DownloadAttachmentParams) (res DownloadAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("downloadAttachment"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/attachments/{id}/download"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "DownloadAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/attachments/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/download"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "DownloadAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeDownloadAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// EnableCurrency invokes enableCurrency operation.
//
// Enable a single currency.
//
// POST /v1/currencies/{code}/enable
func (c *Client) EnableCurrency(ctx context.Context, params EnableCurrencyParams) (EnableCurrencyRes, error) {
        res, err := c.sendEnableCurrency(ctx, params)
        return res, err
}

func (c *Client) sendEnableCurrency(ctx context.Context, params EnableCurrencyParams) (res EnableCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("enableCurrency"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/enable"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "EnableCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/enable"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "EnableCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeEnableCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportAccounts invokes exportAccounts operation.
//
// This endpoint allows you to export your accounts from Firefly III into a file. Currently supports
// CSV exports only.
//
// GET /v1/data/export/accounts
func (c *Client) ExportAccounts(ctx context.Context, params ExportAccountsParams) (ExportAccountsRes, error) {
        res, err := c.sendExportAccounts(ctx, params)
        return res, err
}

func (c *Client) sendExportAccounts(ctx context.Context, params ExportAccountsParams) (res ExportAccountsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportAccounts"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/accounts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportAccounts",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportAccounts", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportAccountsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportBills invokes exportBills operation.
//
// This endpoint allows you to export your bills from Firefly III into a file. Currently supports CSV
// exports only.
//
// GET /v1/data/export/bills
func (c *Client) ExportBills(ctx context.Context, params ExportBillsParams) (ExportBillsRes, error) {
        res, err := c.sendExportBills(ctx, params)
        return res, err
}

func (c *Client) sendExportBills(ctx context.Context, params ExportBillsParams) (res ExportBillsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportBills"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/bills"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportBills",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportBills", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportBillsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportBudgets invokes exportBudgets operation.
//
// This endpoint allows you to export your budgets and associated budget data from Firefly III into a
// file. Currently supports CSV exports only.
//
// GET /v1/data/export/budgets
func (c *Client) ExportBudgets(ctx context.Context, params ExportBudgetsParams) (ExportBudgetsRes, error) {
        res, err := c.sendExportBudgets(ctx, params)
        return res, err
}

func (c *Client) sendExportBudgets(ctx context.Context, params ExportBudgetsParams) (res ExportBudgetsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportBudgets"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/budgets"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportBudgets",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportBudgets", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportBudgetsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportCategories invokes exportCategories operation.
//
// This endpoint allows you to export your categories from Firefly III into a file. Currently
// supports CSV exports only.
//
// GET /v1/data/export/categories
func (c *Client) ExportCategories(ctx context.Context, params ExportCategoriesParams) (ExportCategoriesRes, error) {
        res, err := c.sendExportCategories(ctx, params)
        return res, err
}

func (c *Client) sendExportCategories(ctx context.Context, params ExportCategoriesParams) (res ExportCategoriesRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportCategories"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/categories"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportCategories",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/categories"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportCategories", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportCategoriesResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportPiggies invokes exportPiggies operation.
//
// This endpoint allows you to export your piggy banks from Firefly III into a file. Currently
// supports CSV exports only.
//
// GET /v1/data/export/piggy-banks
func (c *Client) ExportPiggies(ctx context.Context, params ExportPiggiesParams) (ExportPiggiesRes, error) {
        res, err := c.sendExportPiggies(ctx, params)
        return res, err
}

func (c *Client) sendExportPiggies(ctx context.Context, params ExportPiggiesParams) (res ExportPiggiesRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportPiggies"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportPiggies",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportPiggies", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportPiggiesResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportRecurring invokes exportRecurring operation.
//
// This endpoint allows you to export your recurring transactions from Firefly III into a file.
// Currently supports CSV exports only.
//
// GET /v1/data/export/recurring
func (c *Client) ExportRecurring(ctx context.Context, params ExportRecurringParams) (ExportRecurringRes, error) {
        res, err := c.sendExportRecurring(ctx, params)
        return res, err
}

func (c *Client) sendExportRecurring(ctx context.Context, params ExportRecurringParams) (res ExportRecurringRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportRecurring"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/recurring"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportRecurring",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/recurring"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportRecurring", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportRecurringResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportRules invokes exportRules operation.
//
// This endpoint allows you to export your rules and rule groups from Firefly III into a file.
// Currently supports CSV exports only.
//
// GET /v1/data/export/rules
func (c *Client) ExportRules(ctx context.Context, params ExportRulesParams) (ExportRulesRes, error) {
        res, err := c.sendExportRules(ctx, params)
        return res, err
}

func (c *Client) sendExportRules(ctx context.Context, params ExportRulesParams) (res ExportRulesRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportRules"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportRules",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportRules", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportRulesResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportTags invokes exportTags operation.
//
// This endpoint allows you to export your tags from Firefly III into a file. Currently supports CSV
// exports only.
//
// GET /v1/data/export/tags
func (c *Client) ExportTags(ctx context.Context, params ExportTagsParams) (ExportTagsRes, error) {
        res, err := c.sendExportTags(ctx, params)
        return res, err
}

func (c *Client) sendExportTags(ctx context.Context, params ExportTagsParams) (res ExportTagsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportTags"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/tags"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportTags",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/tags"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportTags", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportTagsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ExportTransactions invokes exportTransactions operation.
//
// This endpoint allows you to export transactions from Firefly III into a file. Currently supports
// CSV exports only.
//
// GET /v1/data/export/transactions
func (c *Client) ExportTransactions(ctx context.Context, params ExportTransactionsParams) (ExportTransactionsRes, error) {
        res, err := c.sendExportTransactions(ctx, params)
        return res, err
}

func (c *Client) sendExportTransactions(ctx context.Context, params ExportTransactionsParams) (res ExportTransactionsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("exportTransactions"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/data/export/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ExportTransactions",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/export/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts",
                        Style:   uri.QueryStyleForm,
                        Explode: false,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Accounts.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ExportTransactions", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeExportTransactionsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// FireRule invokes fireRule operation.
//
// Fire the rule group on your transactions. Changes will be made by the rules in the group! Limit
// the result if you want to.
//
// POST /v1/rules/{id}/trigger
func (c *Client) FireRule(ctx context.Context, params FireRuleParams) (FireRuleRes, error) {
        res, err := c.sendFireRule(ctx, params)
        return res, err
}

func (c *Client) sendFireRule(ctx context.Context, params FireRuleParams) (res FireRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("fireRule"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/rules/{id}/trigger"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "FireRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/rules/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/trigger"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "FireRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeFireRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// FireRuleGroup invokes fireRuleGroup operation.
//
// Fire the rule group on your transactions. Changes will be made by the rules in the rule group!
// Limit the result if you want to.
//
// POST /v1/rule-groups/{id}/trigger
func (c *Client) FireRuleGroup(ctx context.Context, params FireRuleGroupParams) (FireRuleGroupRes, error) {
        res, err := c.sendFireRuleGroup(ctx, params)
        return res, err
}

func (c *Client) sendFireRuleGroup(ctx context.Context, params FireRuleGroupParams) (res FireRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("fireRuleGroup"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}/trigger"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "FireRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/trigger"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "FireRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeFireRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetAbout invokes getAbout operation.
//
// Returns general system information and versions of the (supporting) software.
//
// GET /v1/about
func (c *Client) GetAbout(ctx context.Context, params GetAboutParams) (GetAboutRes, error) {
        res, err := c.sendGetAbout(ctx, params)
        return res, err
}

func (c *Client) sendGetAbout(ctx context.Context, params GetAboutParams) (res GetAboutRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getAbout"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/about"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetAbout",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/about"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetAbout", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetAboutResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetAccount invokes getAccount operation.
//
// Returns a single account by its ID.
//
// GET /v1/accounts/{id}
func (c *Client) GetAccount(ctx context.Context, params GetAccountParams) (GetAccountRes, error) {
        res, err := c.sendGetAccount(ctx, params)
        return res, err
}

func (c *Client) sendGetAccount(ctx context.Context, params GetAccountParams) (res GetAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getAccount"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "date" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "date",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Date.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetAccountsAC invokes getAccountsAC operation.
//
// Returns all accounts of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/accounts
func (c *Client) GetAccountsAC(ctx context.Context, params GetAccountsACParams) (GetAccountsACRes, error) {
        res, err := c.sendGetAccountsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetAccountsAC(ctx context.Context, params GetAccountsACParams) (res GetAccountsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getAccountsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/accounts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetAccountsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "date" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "date",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Date.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "types" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "types",
                        Style:   uri.QueryStyleForm,
                        Explode: false,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Types {
                                        if err := func() error {
                                                return e.EncodeValue(conv.StringToString(string(item)))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetAccountsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetAccountsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetAttachment invokes getAttachment operation.
//
// Get a single attachment. This endpoint only returns the available metadata for the attachment.
// Actual file data is handled in two other endpoints (see below).
//
// GET /v1/attachments/{id}
func (c *Client) GetAttachment(ctx context.Context, params GetAttachmentParams) (GetAttachmentRes, error) {
        res, err := c.sendGetAttachment(ctx, params)
        return res, err
}

func (c *Client) sendGetAttachment(ctx context.Context, params GetAttachmentParams) (res GetAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getAttachment"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/attachments/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/attachments/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetAvailableBudget invokes getAvailableBudget operation.
//
// Get a single available budget, by ID.
//
// GET /v1/available-budgets/{id}
func (c *Client) GetAvailableBudget(ctx context.Context, params GetAvailableBudgetParams) (GetAvailableBudgetRes, error) {
        res, err := c.sendGetAvailableBudget(ctx, params)
        return res, err
}

func (c *Client) sendGetAvailableBudget(ctx context.Context, params GetAvailableBudgetParams) (res GetAvailableBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getAvailableBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/available-budgets/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetAvailableBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/available-budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetAvailableBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetAvailableBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBasicSummary invokes getBasicSummary operation.
//
// Returns basic sums of the users data, like the net worth, spent and earned amounts. It is
// multi-currency, and is used in Firefly III to populate the dashboard.
//
// GET /v1/summary/basic
func (c *Client) GetBasicSummary(ctx context.Context, params GetBasicSummaryParams) (GetBasicSummaryRes, error) {
        res, err := c.sendGetBasicSummary(ctx, params)
        return res, err
}

func (c *Client) sendGetBasicSummary(ctx context.Context, params GetBasicSummaryParams) (res GetBasicSummaryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBasicSummary"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/summary/basic"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBasicSummary",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/summary/basic"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "currency_code" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "currency_code",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.CurrencyCode.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBasicSummary", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBasicSummaryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBill invokes getBill operation.
//
// Get a single bill.
//
// GET /v1/bills/{id}
func (c *Client) GetBill(ctx context.Context, params GetBillParams) (GetBillRes, error) {
        res, err := c.sendGetBill(ctx, params)
        return res, err
}

func (c *Client) sendGetBill(ctx context.Context, params GetBillParams) (res GetBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBillsAC invokes getBillsAC operation.
//
// Returns all bills of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/bills
func (c *Client) GetBillsAC(ctx context.Context, params GetBillsACParams) (GetBillsACRes, error) {
        res, err := c.sendGetBillsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetBillsAC(ctx context.Context, params GetBillsACParams) (res GetBillsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBillsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/bills"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBillsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBillsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBillsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBudget invokes getBudget operation.
//
// Get a single budget. If the start date and end date are submitted as well, the "spent" array will
// be updated accordingly.
//
// GET /v1/budgets/{id}
func (c *Client) GetBudget(ctx context.Context, params GetBudgetParams) (GetBudgetRes, error) {
        res, err := c.sendGetBudget(ctx, params)
        return res, err
}

func (c *Client) sendGetBudget(ctx context.Context, params GetBudgetParams) (res GetBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBudgetLimit invokes getBudgetLimit operation.
//
// Get single budget limit.
//
// GET /v1/budgets/{id}/limits/{limitId}
func (c *Client) GetBudgetLimit(ctx context.Context, params GetBudgetLimitParams) (GetBudgetLimitRes, error) {
        res, err := c.sendGetBudgetLimit(ctx, params)
        return res, err
}

func (c *Client) sendGetBudgetLimit(ctx context.Context, params GetBudgetLimitParams) (res GetBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBudgetLimit"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits/{limitId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [4]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits/"
        {
                // Encode "limitId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "limitId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.LimitId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetBudgetsAC invokes getBudgetsAC operation.
//
// Returns all budgets of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/budgets
func (c *Client) GetBudgetsAC(ctx context.Context, params GetBudgetsACParams) (GetBudgetsACRes, error) {
        res, err := c.sendGetBudgetsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetBudgetsAC(ctx context.Context, params GetBudgetsACParams) (res GetBudgetsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getBudgetsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/budgets"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetBudgetsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetBudgetsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetBudgetsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCategoriesAC invokes getCategoriesAC operation.
//
// Returns all categories of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/categories
func (c *Client) GetCategoriesAC(ctx context.Context, params GetCategoriesACParams) (GetCategoriesACRes, error) {
        res, err := c.sendGetCategoriesAC(ctx, params)
        return res, err
}

func (c *Client) sendGetCategoriesAC(ctx context.Context, params GetCategoriesACParams) (res GetCategoriesACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCategoriesAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/categories"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCategoriesAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/categories"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCategoriesAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCategoriesACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCategory invokes getCategory operation.
//
// Get a single category.
//
// GET /v1/categories/{id}
func (c *Client) GetCategory(ctx context.Context, params GetCategoryParams) (GetCategoryRes, error) {
        res, err := c.sendGetCategory(ctx, params)
        return res, err
}

func (c *Client) sendGetCategory(ctx context.Context, params GetCategoryParams) (res GetCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/categories/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/categories/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetChartAccountOverview invokes getChartAccountOverview operation.
//
// This endpoint returns the data required to generate a chart with basic asset account balance
// information.
//
// GET /v1/chart/account/overview
func (c *Client) GetChartAccountOverview(ctx context.Context, params GetChartAccountOverviewParams) (GetChartAccountOverviewRes, error) {
        res, err := c.sendGetChartAccountOverview(ctx, params)
        return res, err
}

func (c *Client) sendGetChartAccountOverview(ctx context.Context, params GetChartAccountOverviewParams) (res GetChartAccountOverviewRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getChartAccountOverview"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/chart/account/overview"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetChartAccountOverview",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/chart/account/overview"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetChartAccountOverview", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetChartAccountOverviewResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetConfiguration invokes getConfiguration operation.
//
// Returns all editable and not-editable configuration values for this Firefly III installation.
//
// GET /v1/configuration
func (c *Client) GetConfiguration(ctx context.Context, params GetConfigurationParams) (GetConfigurationRes, error) {
        res, err := c.sendGetConfiguration(ctx, params)
        return res, err
}

func (c *Client) sendGetConfiguration(ctx context.Context, params GetConfigurationParams) (res GetConfigurationRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getConfiguration"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/configuration"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetConfiguration",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/configuration"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetConfiguration", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetConfigurationResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCron invokes getCron operation.
//
// Firefly III has one endpoint for its various cron related tasks. Send a GET to this endpoint
// to run the cron. The cron requires the CLI token to be present. The cron job will fire for all
// users.
//
// GET /v1/cron/{cliToken}
func (c *Client) GetCron(ctx context.Context, params GetCronParams) (GetCronRes, error) {
        res, err := c.sendGetCron(ctx, params)
        return res, err
}

func (c *Client) sendGetCron(ctx context.Context, params GetCronParams) (res GetCronRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCron"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/cron/{cliToken}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCron",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/cron/"
        {
                // Encode "cliToken" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "cliToken",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.CliToken))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "date" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "date",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Date.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "force" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "force",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Force.Get(); ok {
                                return e.EncodeValue(conv.BoolToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCron", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCronResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCurrenciesAC invokes getCurrenciesAC operation.
//
// Returns all currencies of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/currencies
func (c *Client) GetCurrenciesAC(ctx context.Context, params GetCurrenciesACParams) (GetCurrenciesACRes, error) {
        res, err := c.sendGetCurrenciesAC(ctx, params)
        return res, err
}

func (c *Client) sendGetCurrenciesAC(ctx context.Context, params GetCurrenciesACParams) (res GetCurrenciesACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCurrenciesAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/currencies"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCurrenciesAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/currencies"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCurrenciesAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCurrenciesACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCurrenciesCodeAC invokes getCurrenciesCodeAC operation.
//
// Returns all currencies of the user returned in a basic auto-complete array. This endpoint is
// DEPRECATED and I suggest you DO NOT use it.
//
// GET /v1/autocomplete/currencies-with-code
func (c *Client) GetCurrenciesCodeAC(ctx context.Context, params GetCurrenciesCodeACParams) (GetCurrenciesCodeACRes, error) {
        res, err := c.sendGetCurrenciesCodeAC(ctx, params)
        return res, err
}

func (c *Client) sendGetCurrenciesCodeAC(ctx context.Context, params GetCurrenciesCodeACParams) (res GetCurrenciesCodeACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCurrenciesCodeAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/currencies-with-code"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCurrenciesCodeAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/currencies-with-code"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCurrenciesCodeAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCurrenciesCodeACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCurrency invokes getCurrency operation.
//
// Get a single currency.
//
// GET /v1/currencies/{code}
func (c *Client) GetCurrency(ctx context.Context, params GetCurrencyParams) (GetCurrencyRes, error) {
        res, err := c.sendGetCurrency(ctx, params)
        return res, err
}

func (c *Client) sendGetCurrency(ctx context.Context, params GetCurrencyParams) (res GetCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetCurrentUser invokes getCurrentUser operation.
//
// Returns the currently authenticated user.
//
// GET /v1/about/user
func (c *Client) GetCurrentUser(ctx context.Context, params GetCurrentUserParams) (GetCurrentUserRes, error) {
        res, err := c.sendGetCurrentUser(ctx, params)
        return res, err
}

func (c *Client) sendGetCurrentUser(ctx context.Context, params GetCurrentUserParams) (res GetCurrentUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getCurrentUser"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/about/user"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetCurrentUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/about/user"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetCurrentUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetCurrentUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetDefaultCurrency invokes getDefaultCurrency operation.
//
// Get the user's default currency.
//
// GET /v1/currencies/default
func (c *Client) GetDefaultCurrency(ctx context.Context, params GetDefaultCurrencyParams) (GetDefaultCurrencyRes, error) {
        res, err := c.sendGetDefaultCurrency(ctx, params)
        return res, err
}

func (c *Client) sendGetDefaultCurrency(ctx context.Context, params GetDefaultCurrencyParams) (res GetDefaultCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getDefaultCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/default"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetDefaultCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/currencies/default"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetDefaultCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetDefaultCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetLinkType invokes getLinkType operation.
//
// Returns a single link type by its ID.
//
// GET /v1/link-types/{id}
func (c *Client) GetLinkType(ctx context.Context, params GetLinkTypeParams) (GetLinkTypeRes, error) {
        res, err := c.sendGetLinkType(ctx, params)
        return res, err
}

func (c *Client) sendGetLinkType(ctx context.Context, params GetLinkTypeParams) (res GetLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getLinkType"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/link-types/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/link-types/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetObjectGroup invokes getObjectGroup operation.
//
// Get a single object group.
//
// GET /v1/object-groups/{id}
func (c *Client) GetObjectGroup(ctx context.Context, params GetObjectGroupParams) (GetObjectGroupRes, error) {
        res, err := c.sendGetObjectGroup(ctx, params)
        return res, err
}

func (c *Client) sendGetObjectGroup(ctx context.Context, params GetObjectGroupParams) (res GetObjectGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getObjectGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/object-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetObjectGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/object-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetObjectGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetObjectGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetObjectGroupsAC invokes getObjectGroupsAC operation.
//
// Returns all object groups of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/object-groups
func (c *Client) GetObjectGroupsAC(ctx context.Context, params GetObjectGroupsACParams) (GetObjectGroupsACRes, error) {
        res, err := c.sendGetObjectGroupsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetObjectGroupsAC(ctx context.Context, params GetObjectGroupsACParams) (res GetObjectGroupsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getObjectGroupsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/object-groups"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetObjectGroupsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/object-groups"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetObjectGroupsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetObjectGroupsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetPiggiesAC invokes getPiggiesAC operation.
//
// Returns all piggy banks of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/piggy-banks
func (c *Client) GetPiggiesAC(ctx context.Context, params GetPiggiesACParams) (GetPiggiesACRes, error) {
        res, err := c.sendGetPiggiesAC(ctx, params)
        return res, err
}

func (c *Client) sendGetPiggiesAC(ctx context.Context, params GetPiggiesACParams) (res GetPiggiesACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getPiggiesAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetPiggiesAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetPiggiesAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetPiggiesACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetPiggiesBalanceAC invokes getPiggiesBalanceAC operation.
//
// Returns all piggy banks of the user returned in a basic auto-complete array complemented with
// balance information.
//
// GET /v1/autocomplete/piggy-banks-with-balance
func (c *Client) GetPiggiesBalanceAC(ctx context.Context, params GetPiggiesBalanceACParams) (GetPiggiesBalanceACRes, error) {
        res, err := c.sendGetPiggiesBalanceAC(ctx, params)
        return res, err
}

func (c *Client) sendGetPiggiesBalanceAC(ctx context.Context, params GetPiggiesBalanceACParams) (res GetPiggiesBalanceACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getPiggiesBalanceAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/piggy-banks-with-balance"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetPiggiesBalanceAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/piggy-banks-with-balance"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetPiggiesBalanceAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetPiggiesBalanceACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetPiggyBank invokes getPiggyBank operation.
//
// Get a single piggy bank.
//
// GET /v1/piggy-banks/{id}
func (c *Client) GetPiggyBank(ctx context.Context, params GetPiggyBankParams) (GetPiggyBankRes, error) {
        res, err := c.sendGetPiggyBank(ctx, params)
        return res, err
}

func (c *Client) sendGetPiggyBank(ctx context.Context, params GetPiggyBankParams) (res GetPiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getPiggyBank"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetPiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/piggy-banks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetPiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetPiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetPreference invokes getPreference operation.
//
// Return a single preference and the value.
//
// GET /v1/preferences/{name}
func (c *Client) GetPreference(ctx context.Context, params GetPreferenceParams) (GetPreferenceRes, error) {
        res, err := c.sendGetPreference(ctx, params)
        return res, err
}

func (c *Client) sendGetPreference(ctx context.Context, params GetPreferenceParams) (res GetPreferenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getPreference"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/preferences/{name}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetPreference",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/preferences/"
        {
                // Encode "name" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "name",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Name))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetPreference", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetPreferenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRecurrence invokes getRecurrence operation.
//
// Get a single recurring transaction.
//
// GET /v1/recurrences/{id}
func (c *Client) GetRecurrence(ctx context.Context, params GetRecurrenceParams) (GetRecurrenceRes, error) {
        res, err := c.sendGetRecurrence(ctx, params)
        return res, err
}

func (c *Client) sendGetRecurrence(ctx context.Context, params GetRecurrenceParams) (res GetRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRecurrence"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/recurrences/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/recurrences/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRecurringAC invokes getRecurringAC operation.
//
// Returns all recurring transactions of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/recurring
func (c *Client) GetRecurringAC(ctx context.Context, params GetRecurringACParams) (GetRecurringACRes, error) {
        res, err := c.sendGetRecurringAC(ctx, params)
        return res, err
}

func (c *Client) sendGetRecurringAC(ctx context.Context, params GetRecurringACParams) (res GetRecurringACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRecurringAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/recurring"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRecurringAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/recurring"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRecurringAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRecurringACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRule invokes getRule operation.
//
// Get a single rule.
//
// GET /v1/rules/{id}
func (c *Client) GetRule(ctx context.Context, params GetRuleParams) (GetRuleRes, error) {
        res, err := c.sendGetRule(ctx, params)
        return res, err
}

func (c *Client) sendGetRule(ctx context.Context, params GetRuleParams) (res GetRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRule"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rules/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rules/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRuleGroup invokes getRuleGroup operation.
//
// Get a single rule group. This does not include the rules. For that, see below.
//
// GET /v1/rule-groups/{id}
func (c *Client) GetRuleGroup(ctx context.Context, params GetRuleGroupParams) (GetRuleGroupRes, error) {
        res, err := c.sendGetRuleGroup(ctx, params)
        return res, err
}

func (c *Client) sendGetRuleGroup(ctx context.Context, params GetRuleGroupParams) (res GetRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRuleGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRuleGroupsAC invokes getRuleGroupsAC operation.
//
// Returns all rule groups of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/rule-groups
func (c *Client) GetRuleGroupsAC(ctx context.Context, params GetRuleGroupsACParams) (GetRuleGroupsACRes, error) {
        res, err := c.sendGetRuleGroupsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetRuleGroupsAC(ctx context.Context, params GetRuleGroupsACParams) (res GetRuleGroupsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRuleGroupsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/rule-groups"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRuleGroupsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/rule-groups"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRuleGroupsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRuleGroupsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetRulesAC invokes getRulesAC operation.
//
// Returns all rules of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/rules
func (c *Client) GetRulesAC(ctx context.Context, params GetRulesACParams) (GetRulesACRes, error) {
        res, err := c.sendGetRulesAC(ctx, params)
        return res, err
}

func (c *Client) sendGetRulesAC(ctx context.Context, params GetRulesACParams) (res GetRulesACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getRulesAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetRulesAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetRulesAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetRulesACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetSingleConfiguration invokes getSingleConfiguration operation.
//
// Returns one configuration variable for this Firefly III installation.
//
// GET /v1/configuration/{name}
func (c *Client) GetSingleConfiguration(ctx context.Context, params GetSingleConfigurationParams) (GetSingleConfigurationRes, error) {
        res, err := c.sendGetSingleConfiguration(ctx, params)
        return res, err
}

func (c *Client) sendGetSingleConfiguration(ctx context.Context, params GetSingleConfigurationParams) (res GetSingleConfigurationRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getSingleConfiguration"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/configuration/{name}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetSingleConfiguration",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/configuration/"
        {
                // Encode "name" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "name",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(string(params.Name)))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetSingleConfiguration", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetSingleConfigurationResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetSingleWebhookMessage invokes getSingleWebhookMessage operation.
//
// When a webhook is triggered it will store the actual content of the webhook in a webhook message.
// You can view and analyse a single one using this endpoint.
//
// GET /v1/webhooks/{id}/messages/{messageId}
func (c *Client) GetSingleWebhookMessage(ctx context.Context, params GetSingleWebhookMessageParams) (GetSingleWebhookMessageRes, error) {
        res, err := c.sendGetSingleWebhookMessage(ctx, params)
        return res, err
}

func (c *Client) sendGetSingleWebhookMessage(ctx context.Context, params GetSingleWebhookMessageParams) (res GetSingleWebhookMessageRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getSingleWebhookMessage"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages/{messageId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetSingleWebhookMessage",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [4]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages/"
        {
                // Encode "messageId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "messageId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.MessageId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetSingleWebhookMessage", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetSingleWebhookMessageResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetSingleWebhookMessageAttempt invokes getSingleWebhookMessageAttempt operation.
//
// When a webhook message fails to send it will store the failure in an "attempt". You can view and
// analyse these. Webhooks messages that receive too many attempts (failures) will not be fired. You
// must first clear out old attempts and try again. This endpoint shows you the details of a single
// attempt. The ID of the attempt must match the corresponding webhook and webhook message.
//
// GET /v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}
func (c *Client) GetSingleWebhookMessageAttempt(ctx context.Context, params GetSingleWebhookMessageAttemptParams) (GetSingleWebhookMessageAttemptRes, error) {
        res, err := c.sendGetSingleWebhookMessageAttempt(ctx, params)
        return res, err
}

func (c *Client) sendGetSingleWebhookMessageAttempt(ctx context.Context, params GetSingleWebhookMessageAttemptParams) (res GetSingleWebhookMessageAttemptRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getSingleWebhookMessageAttempt"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages/{messageId}/attempts/{attemptId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetSingleWebhookMessageAttempt",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [6]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages/"
        {
                // Encode "messageId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "messageId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.MessageId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        pathParts[4] = "/attempts/"
        {
                // Encode "attemptId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "attemptId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.AttemptId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[5] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetSingleWebhookMessageAttempt", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetSingleWebhookMessageAttemptResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTag invokes getTag operation.
//
// Get a single tag.
//
// GET /v1/tags/{tag}
func (c *Client) GetTag(ctx context.Context, params GetTagParams) (GetTagRes, error) {
        res, err := c.sendGetTag(ctx, params)
        return res, err
}

func (c *Client) sendGetTag(ctx context.Context, params GetTagParams) (res GetTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/tags/{tag}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/tags/"
        {
                // Encode "tag" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "tag",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Tag))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTagAC invokes getTagAC operation.
//
// Returns all tags of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/tags
func (c *Client) GetTagAC(ctx context.Context, params GetTagACParams) (GetTagACRes, error) {
        res, err := c.sendGetTagAC(ctx, params)
        return res, err
}

func (c *Client) sendGetTagAC(ctx context.Context, params GetTagACParams) (res GetTagACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTagAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/tags"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTagAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/tags"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTagAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTagACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransaction invokes getTransaction operation.
//
// Get a single transaction.
//
// GET /v1/transactions/{id}
func (c *Client) GetTransaction(ctx context.Context, params GetTransactionParams) (GetTransactionRes, error) {
        res, err := c.sendGetTransaction(ctx, params)
        return res, err
}

func (c *Client) sendGetTransaction(ctx context.Context, params GetTransactionParams) (res GetTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransaction"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transactions/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transactions/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransactionByJournal invokes getTransactionByJournal operation.
//
// Get a single transaction by underlying journal (split).
//
// GET /v1/transaction-journals/{id}
func (c *Client) GetTransactionByJournal(ctx context.Context, params GetTransactionByJournalParams) (GetTransactionByJournalRes, error) {
        res, err := c.sendGetTransactionByJournal(ctx, params)
        return res, err
}

func (c *Client) sendGetTransactionByJournal(ctx context.Context, params GetTransactionByJournalParams) (res GetTransactionByJournalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransactionByJournal"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transaction-journals/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransactionByJournal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transaction-journals/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransactionByJournal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionByJournalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransactionLink invokes getTransactionLink operation.
//
// Returns a single link by its ID.
//
// GET /v1/transaction-links/{id}
func (c *Client) GetTransactionLink(ctx context.Context, params GetTransactionLinkParams) (GetTransactionLinkRes, error) {
        res, err := c.sendGetTransactionLink(ctx, params)
        return res, err
}

func (c *Client) sendGetTransactionLink(ctx context.Context, params GetTransactionLinkParams) (res GetTransactionLinkRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransactionLink"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transaction-links/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransactionLink",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transaction-links/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransactionLink", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionLinkResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransactionTypesAC invokes getTransactionTypesAC operation.
//
// Returns all transaction types returned in a basic auto-complete array. English only.
//
// GET /v1/autocomplete/transaction-types
func (c *Client) GetTransactionTypesAC(ctx context.Context, params GetTransactionTypesACParams) (GetTransactionTypesACRes, error) {
        res, err := c.sendGetTransactionTypesAC(ctx, params)
        return res, err
}

func (c *Client) sendGetTransactionTypesAC(ctx context.Context, params GetTransactionTypesACParams) (res GetTransactionTypesACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransactionTypesAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/transaction-types"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransactionTypesAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/transaction-types"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransactionTypesAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionTypesACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransactionsAC invokes getTransactionsAC operation.
//
// Returns all transaction descriptions of the user returned in a basic auto-complete array.
//
// GET /v1/autocomplete/transactions
func (c *Client) GetTransactionsAC(ctx context.Context, params GetTransactionsACParams) (GetTransactionsACRes, error) {
        res, err := c.sendGetTransactionsAC(ctx, params)
        return res, err
}

func (c *Client) sendGetTransactionsAC(ctx context.Context, params GetTransactionsACParams) (res GetTransactionsACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransactionsAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransactionsAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransactionsAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionsACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetTransactionsIDAC invokes getTransactionsIDAC operation.
//
// Returns all transactions, complemented with their ID, of the user returned in a basic
// auto-complete array. This endpoint is DEPRECATED and I suggest you DO NOT use it.
//
// GET /v1/autocomplete/transactions-with-id
func (c *Client) GetTransactionsIDAC(ctx context.Context, params GetTransactionsIDACParams) (GetTransactionsIDACRes, error) {
        res, err := c.sendGetTransactionsIDAC(ctx, params)
        return res, err
}

func (c *Client) sendGetTransactionsIDAC(ctx context.Context, params GetTransactionsIDACParams) (res GetTransactionsIDACRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getTransactionsIDAC"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/autocomplete/transactions-with-id"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetTransactionsIDAC",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/autocomplete/transactions-with-id"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Query.Get(); ok {
                                return e.EncodeValue(conv.StringToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetTransactionsIDAC", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetTransactionsIDACResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetUser invokes getUser operation.
//
// Gets all info of a single user.
//
// GET /v1/users/{id}
func (c *Client) GetUser(ctx context.Context, params GetUserParams) (GetUserRes, error) {
        res, err := c.sendGetUser(ctx, params)
        return res, err
}

func (c *Client) sendGetUser(ctx context.Context, params GetUserParams) (res GetUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getUser"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/users/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/users/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetWebhook invokes getWebhook operation.
//
// Gets all info of a single webhook.
//
// GET /v1/webhooks/{id}
func (c *Client) GetWebhook(ctx context.Context, params GetWebhookParams) (GetWebhookRes, error) {
        res, err := c.sendGetWebhook(ctx, params)
        return res, err
}

func (c *Client) sendGetWebhook(ctx context.Context, params GetWebhookParams) (res GetWebhookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getWebhook"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetWebhook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetWebhook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetWebhookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetWebhookMessageAttempts invokes getWebhookMessageAttempts operation.
//
// When a webhook message fails to send it will store the failure in an "attempt". You can view and
// analyse these. Webhook messages that receive too many attempts (failures) will not be sent again.
// You must first clear out old attempts before the message can go out again.
//
// GET /v1/webhooks/{id}/messages/{messageId}/attempts
func (c *Client) GetWebhookMessageAttempts(ctx context.Context, params GetWebhookMessageAttemptsParams) (GetWebhookMessageAttemptsRes, error) {
        res, err := c.sendGetWebhookMessageAttempts(ctx, params)
        return res, err
}

func (c *Client) sendGetWebhookMessageAttempts(ctx context.Context, params GetWebhookMessageAttemptsParams) (res GetWebhookMessageAttemptsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getWebhookMessageAttempts"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages/{messageId}/attempts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetWebhookMessageAttempts",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [5]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages/"
        {
                // Encode "messageId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "messageId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.IntToString(params.MessageId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        pathParts[4] = "/attempts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetWebhookMessageAttempts", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetWebhookMessageAttemptsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// GetWebhookMessages invokes getWebhookMessages operation.
//
// When a webhook is triggered the actual message that will be send is stored in a "message". You can
// view and analyse these messages.
//
// GET /v1/webhooks/{id}/messages
func (c *Client) GetWebhookMessages(ctx context.Context, params GetWebhookMessagesParams) (GetWebhookMessagesRes, error) {
        res, err := c.sendGetWebhookMessages(ctx, params)
        return res, err
}

func (c *Client) sendGetWebhookMessages(ctx context.Context, params GetWebhookMessagesParams) (res GetWebhookMessagesRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("getWebhookMessages"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/messages"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "GetWebhookMessages",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/messages"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "GetWebhookMessages", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeGetWebhookMessagesResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseAsset invokes insightExpenseAsset operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by asset account.
//
// GET /v1/insight/expense/asset
func (c *Client) InsightExpenseAsset(ctx context.Context, params InsightExpenseAssetParams) (InsightExpenseAssetRes, error) {
        res, err := c.sendInsightExpenseAsset(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseAsset(ctx context.Context, params InsightExpenseAssetParams) (res InsightExpenseAssetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseAsset"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/asset"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseAsset",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/asset"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseAsset", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseAssetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseBill invokes insightExpenseBill operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by (any) bill.
//
// GET /v1/insight/expense/bill
func (c *Client) InsightExpenseBill(ctx context.Context, params InsightExpenseBillParams) (InsightExpenseBillRes, error) {
        res, err := c.sendInsightExpenseBill(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseBill(ctx context.Context, params InsightExpenseBillParams) (res InsightExpenseBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/bill"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/bill"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "bills[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "bills[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Bills {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseBudget invokes insightExpenseBudget operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by (any) budget.
//
// GET /v1/insight/expense/budget
func (c *Client) InsightExpenseBudget(ctx context.Context, params InsightExpenseBudgetParams) (InsightExpenseBudgetRes, error) {
        res, err := c.sendInsightExpenseBudget(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseBudget(ctx context.Context, params InsightExpenseBudgetParams) (res InsightExpenseBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/budget"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/budget"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "budgets[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "budgets[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Budgets {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseCategory invokes insightExpenseCategory operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by (any) category.
//
// GET /v1/insight/expense/category
func (c *Client) InsightExpenseCategory(ctx context.Context, params InsightExpenseCategoryParams) (InsightExpenseCategoryRes, error) {
        res, err := c.sendInsightExpenseCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseCategory(ctx context.Context, params InsightExpenseCategoryParams) (res InsightExpenseCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "categories[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "categories[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Categories {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseExpense invokes insightExpenseExpense operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by expense account.
//
// GET /v1/insight/expense/expense
func (c *Client) InsightExpenseExpense(ctx context.Context, params InsightExpenseExpenseParams) (InsightExpenseExpenseRes, error) {
        res, err := c.sendInsightExpenseExpense(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseExpense(ctx context.Context, params InsightExpenseExpenseParams) (res InsightExpenseExpenseRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseExpense"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/expense"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseExpense",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/expense"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseExpense", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseExpenseResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseNoBill invokes insightExpenseNoBill operation.
//
// This endpoint gives a summary of the expenses made by the user, including only expenses with no
// bill.
//
// GET /v1/insight/expense/no-bill
func (c *Client) InsightExpenseNoBill(ctx context.Context, params InsightExpenseNoBillParams) (InsightExpenseNoBillRes, error) {
        res, err := c.sendInsightExpenseNoBill(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseNoBill(ctx context.Context, params InsightExpenseNoBillParams) (res InsightExpenseNoBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseNoBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/no-bill"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseNoBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/no-bill"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseNoBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseNoBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseNoBudget invokes insightExpenseNoBudget operation.
//
// This endpoint gives a summary of the expenses made by the user, including only expenses with no
// budget.
//
// GET /v1/insight/expense/no-budget
func (c *Client) InsightExpenseNoBudget(ctx context.Context, params InsightExpenseNoBudgetParams) (InsightExpenseNoBudgetRes, error) {
        res, err := c.sendInsightExpenseNoBudget(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseNoBudget(ctx context.Context, params InsightExpenseNoBudgetParams) (res InsightExpenseNoBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseNoBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/no-budget"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseNoBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/no-budget"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseNoBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseNoBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseNoCategory invokes insightExpenseNoCategory operation.
//
// This endpoint gives a summary of the expenses made by the user, including only expenses with no
// category.
//
// GET /v1/insight/expense/no-category
func (c *Client) InsightExpenseNoCategory(ctx context.Context, params InsightExpenseNoCategoryParams) (InsightExpenseNoCategoryRes, error) {
        res, err := c.sendInsightExpenseNoCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseNoCategory(ctx context.Context, params InsightExpenseNoCategoryParams) (res InsightExpenseNoCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseNoCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/no-category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseNoCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/no-category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseNoCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseNoCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseNoTag invokes insightExpenseNoTag operation.
//
// This endpoint gives a summary of the expenses made by the user, including only expenses with no
// tag.
//
// GET /v1/insight/expense/no-tag
func (c *Client) InsightExpenseNoTag(ctx context.Context, params InsightExpenseNoTagParams) (InsightExpenseNoTagRes, error) {
        res, err := c.sendInsightExpenseNoTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseNoTag(ctx context.Context, params InsightExpenseNoTagParams) (res InsightExpenseNoTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseNoTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/no-tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseNoTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/no-tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseNoTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseNoTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseTag invokes insightExpenseTag operation.
//
// This endpoint gives a summary of the expenses made by the user, grouped by (any) tag.
//
// GET /v1/insight/expense/tag
func (c *Client) InsightExpenseTag(ctx context.Context, params InsightExpenseTagParams) (InsightExpenseTagRes, error) {
        res, err := c.sendInsightExpenseTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseTag(ctx context.Context, params InsightExpenseTagParams) (res InsightExpenseTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "tags[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "tags[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Tags {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightExpenseTotal invokes insightExpenseTotal operation.
//
// This endpoint gives a sum of the total expenses made by the user.
//
// GET /v1/insight/expense/total
func (c *Client) InsightExpenseTotal(ctx context.Context, params InsightExpenseTotalParams) (InsightExpenseTotalRes, error) {
        res, err := c.sendInsightExpenseTotal(ctx, params)
        return res, err
}

func (c *Client) sendInsightExpenseTotal(ctx context.Context, params InsightExpenseTotalParams) (res InsightExpenseTotalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightExpenseTotal"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/expense/total"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightExpenseTotal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/expense/total"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightExpenseTotal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightExpenseTotalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeAsset invokes insightIncomeAsset operation.
//
// This endpoint gives a summary of the income received by the user, grouped by asset account.
//
// GET /v1/insight/income/asset
func (c *Client) InsightIncomeAsset(ctx context.Context, params InsightIncomeAssetParams) (InsightIncomeAssetRes, error) {
        res, err := c.sendInsightIncomeAsset(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeAsset(ctx context.Context, params InsightIncomeAssetParams) (res InsightIncomeAssetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeAsset"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/asset"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeAsset",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/asset"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeAsset", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeAssetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeCategory invokes insightIncomeCategory operation.
//
// This endpoint gives a summary of the income received by the user, grouped by (any) category.
//
// GET /v1/insight/income/category
func (c *Client) InsightIncomeCategory(ctx context.Context, params InsightIncomeCategoryParams) (InsightIncomeCategoryRes, error) {
        res, err := c.sendInsightIncomeCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeCategory(ctx context.Context, params InsightIncomeCategoryParams) (res InsightIncomeCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "categories[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "categories[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Categories {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeNoCategory invokes insightIncomeNoCategory operation.
//
// This endpoint gives a summary of the income received by the user, including only income with no
// category.
//
// GET /v1/insight/income/no-category
func (c *Client) InsightIncomeNoCategory(ctx context.Context, params InsightIncomeNoCategoryParams) (InsightIncomeNoCategoryRes, error) {
        res, err := c.sendInsightIncomeNoCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeNoCategory(ctx context.Context, params InsightIncomeNoCategoryParams) (res InsightIncomeNoCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeNoCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/no-category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeNoCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/no-category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeNoCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeNoCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeNoTag invokes insightIncomeNoTag operation.
//
// This endpoint gives a summary of the income received by the user, including only income with no
// tag.
//
// GET /v1/insight/income/no-tag
func (c *Client) InsightIncomeNoTag(ctx context.Context, params InsightIncomeNoTagParams) (InsightIncomeNoTagRes, error) {
        res, err := c.sendInsightIncomeNoTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeNoTag(ctx context.Context, params InsightIncomeNoTagParams) (res InsightIncomeNoTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeNoTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/no-tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeNoTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/no-tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeNoTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeNoTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeRevenue invokes insightIncomeRevenue operation.
//
// This endpoint gives a summary of the income received by the user, grouped by revenue account.
//
// GET /v1/insight/income/revenue
func (c *Client) InsightIncomeRevenue(ctx context.Context, params InsightIncomeRevenueParams) (InsightIncomeRevenueRes, error) {
        res, err := c.sendInsightIncomeRevenue(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeRevenue(ctx context.Context, params InsightIncomeRevenueParams) (res InsightIncomeRevenueRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeRevenue"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/revenue"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeRevenue",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/revenue"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeRevenue", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeRevenueResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeTag invokes insightIncomeTag operation.
//
// This endpoint gives a summary of the income received by the user, grouped by (any) tag.
//
// GET /v1/insight/income/tag
func (c *Client) InsightIncomeTag(ctx context.Context, params InsightIncomeTagParams) (InsightIncomeTagRes, error) {
        res, err := c.sendInsightIncomeTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeTag(ctx context.Context, params InsightIncomeTagParams) (res InsightIncomeTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "tags[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "tags[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Tags {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightIncomeTotal invokes insightIncomeTotal operation.
//
// This endpoint gives a sum of the total income received by the user.
//
// GET /v1/insight/income/total
func (c *Client) InsightIncomeTotal(ctx context.Context, params InsightIncomeTotalParams) (InsightIncomeTotalRes, error) {
        res, err := c.sendInsightIncomeTotal(ctx, params)
        return res, err
}

func (c *Client) sendInsightIncomeTotal(ctx context.Context, params InsightIncomeTotalParams) (res InsightIncomeTotalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightIncomeTotal"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/income/total"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightIncomeTotal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/income/total"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightIncomeTotal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightIncomeTotalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransferCategory invokes insightTransferCategory operation.
//
// This endpoint gives a summary of the transfers made by the user, grouped by (any) category.
//
// GET /v1/insight/transfer/category
func (c *Client) InsightTransferCategory(ctx context.Context, params InsightTransferCategoryParams) (InsightTransferCategoryRes, error) {
        res, err := c.sendInsightTransferCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransferCategory(ctx context.Context, params InsightTransferCategoryParams) (res InsightTransferCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransferCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransferCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "categories[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "categories[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Categories {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransferCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransferCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransferNoCategory invokes insightTransferNoCategory operation.
//
// This endpoint gives a summary of the transfers made by the user, including only transfers with no
// category.
//
// GET /v1/insight/transfer/no-category
func (c *Client) InsightTransferNoCategory(ctx context.Context, params InsightTransferNoCategoryParams) (InsightTransferNoCategoryRes, error) {
        res, err := c.sendInsightTransferNoCategory(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransferNoCategory(ctx context.Context, params InsightTransferNoCategoryParams) (res InsightTransferNoCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransferNoCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/no-category"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransferNoCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/no-category"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransferNoCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransferNoCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransferNoTag invokes insightTransferNoTag operation.
//
// This endpoint gives a summary of the transfers made by the user, including only transfers with no
// tag.
//
// GET /v1/insight/transfer/no-tag
func (c *Client) InsightTransferNoTag(ctx context.Context, params InsightTransferNoTagParams) (InsightTransferNoTagRes, error) {
        res, err := c.sendInsightTransferNoTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransferNoTag(ctx context.Context, params InsightTransferNoTagParams) (res InsightTransferNoTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransferNoTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/no-tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransferNoTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/no-tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransferNoTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransferNoTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransferTag invokes insightTransferTag operation.
//
// This endpoint gives a summary of the transfers created by the user, grouped by (any) tag.
//
// GET /v1/insight/transfer/tag
func (c *Client) InsightTransferTag(ctx context.Context, params InsightTransferTagParams) (InsightTransferTagRes, error) {
        res, err := c.sendInsightTransferTag(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransferTag(ctx context.Context, params InsightTransferTagParams) (res InsightTransferTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransferTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/tag"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransferTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/tag"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "tags[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "tags[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Tags {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransferTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransferTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransferTotal invokes insightTransferTotal operation.
//
// This endpoint gives a sum of the total amount transfers made by the user.
//
// GET /v1/insight/transfer/total
func (c *Client) InsightTransferTotal(ctx context.Context, params InsightTransferTotalParams) (InsightTransferTotalRes, error) {
        res, err := c.sendInsightTransferTotal(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransferTotal(ctx context.Context, params InsightTransferTotalParams) (res InsightTransferTotalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransferTotal"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/total"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransferTotal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/total"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransferTotal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransferTotalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// InsightTransfers invokes insightTransfers operation.
//
// This endpoint gives a summary of the transfers made by the user, grouped by asset account or
// lability.
//
// GET /v1/insight/transfer/asset
func (c *Client) InsightTransfers(ctx context.Context, params InsightTransfersParams) (InsightTransfersRes, error) {
        res, err := c.sendInsightTransfers(ctx, params)
        return res, err
}

func (c *Client) sendInsightTransfers(ctx context.Context, params InsightTransfersParams) (res InsightTransfersRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("insightTransfers"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/insight/transfer/asset"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "InsightTransfers",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/insight/transfer/asset"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "InsightTransfers", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeInsightTransfersResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAccount invokes listAccount operation.
//
// This endpoint returns a list of all the accounts owned by the authenticated user.
//
// GET /v1/accounts
func (c *Client) ListAccount(ctx context.Context, params ListAccountParams) (ListAccountRes, error) {
        res, err := c.sendListAccount(ctx, params)
        return res, err
}

func (c *Client) sendListAccount(ctx context.Context, params ListAccountParams) (res ListAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAccount"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/accounts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.Int32ToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "date" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "date",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Date.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAccountByCurrency invokes listAccountByCurrency operation.
//
// List all accounts with this currency.
//
// GET /v1/currencies/{code}/accounts
func (c *Client) ListAccountByCurrency(ctx context.Context, params ListAccountByCurrencyParams) (ListAccountByCurrencyRes, error) {
        res, err := c.sendListAccountByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListAccountByCurrency(ctx context.Context, params ListAccountByCurrencyParams) (res ListAccountByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAccountByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/accounts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAccountByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "date" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "date",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Date.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAccountByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAccountByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachment invokes listAttachment operation.
//
// This endpoint lists all attachments.
//
// GET /v1/attachments
func (c *Client) ListAttachment(ctx context.Context, params ListAttachmentParams) (ListAttachmentRes, error) {
        res, err := c.sendListAttachment(ctx, params)
        return res, err
}

func (c *Client) sendListAttachment(ctx context.Context, params ListAttachmentParams) (res ListAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachment"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByAccount invokes listAttachmentByAccount operation.
//
// Lists all attachments.
//
// GET /v1/accounts/{id}/attachments
func (c *Client) ListAttachmentByAccount(ctx context.Context, params ListAttachmentByAccountParams) (ListAttachmentByAccountRes, error) {
        res, err := c.sendListAttachmentByAccount(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByAccount(ctx context.Context, params ListAttachmentByAccountParams) (res ListAttachmentByAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByAccount"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByBill invokes listAttachmentByBill operation.
//
// This endpoint will list all attachments linked to the bill.
//
// GET /v1/bills/{id}/attachments
func (c *Client) ListAttachmentByBill(ctx context.Context, params ListAttachmentByBillParams) (ListAttachmentByBillRes, error) {
        res, err := c.sendListAttachmentByBill(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByBill(ctx context.Context, params ListAttachmentByBillParams) (res ListAttachmentByBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByBudget invokes listAttachmentByBudget operation.
//
// Lists all attachments.
//
// GET /v1/budgets/{id}/attachments
func (c *Client) ListAttachmentByBudget(ctx context.Context, params ListAttachmentByBudgetParams) (ListAttachmentByBudgetRes, error) {
        res, err := c.sendListAttachmentByBudget(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByBudget(ctx context.Context, params ListAttachmentByBudgetParams) (res ListAttachmentByBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByCategory invokes listAttachmentByCategory operation.
//
// Lists all attachments.
//
// GET /v1/categories/{id}/attachments
func (c *Client) ListAttachmentByCategory(ctx context.Context, params ListAttachmentByCategoryParams) (ListAttachmentByCategoryRes, error) {
        res, err := c.sendListAttachmentByCategory(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByCategory(ctx context.Context, params ListAttachmentByCategoryParams) (res ListAttachmentByCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/categories/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/categories/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByPiggyBank invokes listAttachmentByPiggyBank operation.
//
// Lists all attachments.
//
// GET /v1/piggy-banks/{id}/attachments
func (c *Client) ListAttachmentByPiggyBank(ctx context.Context, params ListAttachmentByPiggyBankParams) (ListAttachmentByPiggyBankRes, error) {
        res, err := c.sendListAttachmentByPiggyBank(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByPiggyBank(ctx context.Context, params ListAttachmentByPiggyBankParams) (res ListAttachmentByPiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByPiggyBank"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByPiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/piggy-banks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByPiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByPiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByTag invokes listAttachmentByTag operation.
//
// Lists all attachments.
//
// GET /v1/tags/{tag}/attachments
func (c *Client) ListAttachmentByTag(ctx context.Context, params ListAttachmentByTagParams) (ListAttachmentByTagRes, error) {
        res, err := c.sendListAttachmentByTag(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByTag(ctx context.Context, params ListAttachmentByTagParams) (res ListAttachmentByTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/tags/{tag}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/tags/"
        {
                // Encode "tag" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "tag",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Tag))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAttachmentByTransaction invokes listAttachmentByTransaction operation.
//
// Lists all attachments.
//
// GET /v1/transactions/{id}/attachments
func (c *Client) ListAttachmentByTransaction(ctx context.Context, params ListAttachmentByTransactionParams) (ListAttachmentByTransactionRes, error) {
        res, err := c.sendListAttachmentByTransaction(ctx, params)
        return res, err
}

func (c *Client) sendListAttachmentByTransaction(ctx context.Context, params ListAttachmentByTransactionParams) (res ListAttachmentByTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAttachmentByTransaction"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transactions/{id}/attachments"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAttachmentByTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/transactions/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAttachmentByTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAttachmentByTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAvailableBudget invokes listAvailableBudget operation.
//
// Firefly III allows users to set the amount that is available to be budgeted in so-called
// "available budgets". For example, the user could have 1200,- available to be divided during the
// coming month. This amount is used on the /budgets page. This endpoint returns all of these amounts
// and the periods for which they are set.
//
// GET /v1/available-budgets
func (c *Client) ListAvailableBudget(ctx context.Context, params ListAvailableBudgetParams) (ListAvailableBudgetRes, error) {
        res, err := c.sendListAvailableBudget(ctx, params)
        return res, err
}

func (c *Client) sendListAvailableBudget(ctx context.Context, params ListAvailableBudgetParams) (res ListAvailableBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAvailableBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/available-budgets"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAvailableBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/available-budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAvailableBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAvailableBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListAvailableBudgetByCurrency invokes listAvailableBudgetByCurrency operation.
//
// List all available budgets with this currency.
//
// GET /v1/currencies/{code}/available-budgets
func (c *Client) ListAvailableBudgetByCurrency(ctx context.Context, params ListAvailableBudgetByCurrencyParams) (ListAvailableBudgetByCurrencyRes, error) {
        res, err := c.sendListAvailableBudgetByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListAvailableBudgetByCurrency(ctx context.Context, params ListAvailableBudgetByCurrencyParams) (res ListAvailableBudgetByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listAvailableBudgetByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/available-budgets"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListAvailableBudgetByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/available-budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListAvailableBudgetByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListAvailableBudgetByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBill invokes listBill operation.
//
// This endpoint will list all the user's bills.
//
// GET /v1/bills
func (c *Client) ListBill(ctx context.Context, params ListBillParams) (ListBillRes, error) {
        res, err := c.sendListBill(ctx, params)
        return res, err
}

func (c *Client) sendListBill(ctx context.Context, params ListBillParams) (res ListBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/bills"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBillByCurrency invokes listBillByCurrency operation.
//
// List all bills with this currency.
//
// GET /v1/currencies/{code}/bills
func (c *Client) ListBillByCurrency(ctx context.Context, params ListBillByCurrencyParams) (ListBillByCurrencyRes, error) {
        res, err := c.sendListBillByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListBillByCurrency(ctx context.Context, params ListBillByCurrencyParams) (res ListBillByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBillByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/bills"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBillByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBillByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBillByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBillByObjectGroup invokes listBillByObjectGroup operation.
//
// List all bills with this object group.
//
// GET /v1/object-groups/{id}/bills
func (c *Client) ListBillByObjectGroup(ctx context.Context, params ListBillByObjectGroupParams) (ListBillByObjectGroupRes, error) {
        res, err := c.sendListBillByObjectGroup(ctx, params)
        return res, err
}

func (c *Client) sendListBillByObjectGroup(ctx context.Context, params ListBillByObjectGroupParams) (res ListBillByObjectGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBillByObjectGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/object-groups/{id}/bills"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBillByObjectGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/object-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBillByObjectGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBillByObjectGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBudget invokes listBudget operation.
//
// List all the budgets the user has made. If the start date and end date are submitted as well, the
// "spent" array will be updated accordingly.
//
// GET /v1/budgets
func (c *Client) ListBudget(ctx context.Context, params ListBudgetParams) (ListBudgetRes, error) {
        res, err := c.sendListBudget(ctx, params)
        return res, err
}

func (c *Client) sendListBudget(ctx context.Context, params ListBudgetParams) (res ListBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBudgetLimit invokes listBudgetLimit operation.
//
// Get all budget limits for for this date range.
//
// GET /v1/budget-limits
func (c *Client) ListBudgetLimit(ctx context.Context, params ListBudgetLimitParams) (ListBudgetLimitRes, error) {
        res, err := c.sendListBudgetLimit(ctx, params)
        return res, err
}

func (c *Client) sendListBudgetLimit(ctx context.Context, params ListBudgetLimitParams) (res ListBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBudgetLimit"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budget-limits"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/budget-limits"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.Start))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.DateToString(params.End))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBudgetLimitByBudget invokes listBudgetLimitByBudget operation.
//
// Get all budget limits for this budget and the money spent, and money left. You can limit the list
// by submitting a date range as well. The "spent" array for each budget limit is NOT influenced by
// the start and end date of your query, but by the start and end date of the budget limit itself.
//
// GET /v1/budgets/{id}/limits
func (c *Client) ListBudgetLimitByBudget(ctx context.Context, params ListBudgetLimitByBudgetParams) (ListBudgetLimitByBudgetRes, error) {
        res, err := c.sendListBudgetLimitByBudget(ctx, params)
        return res, err
}

func (c *Client) sendListBudgetLimitByBudget(ctx context.Context, params ListBudgetLimitByBudgetParams) (res ListBudgetLimitByBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBudgetLimitByBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBudgetLimitByBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBudgetLimitByBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBudgetLimitByBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListBudgetLimitByCurrency invokes listBudgetLimitByCurrency operation.
//
// List all budget limits with this currency.
//
// GET /v1/currencies/{code}/budget_limits
func (c *Client) ListBudgetLimitByCurrency(ctx context.Context, params ListBudgetLimitByCurrencyParams) (ListBudgetLimitByCurrencyRes, error) {
        res, err := c.sendListBudgetLimitByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListBudgetLimitByCurrency(ctx context.Context, params ListBudgetLimitByCurrencyParams) (res ListBudgetLimitByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listBudgetLimitByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/budget_limits"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListBudgetLimitByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/budget_limits"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListBudgetLimitByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListBudgetLimitByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListCategory invokes listCategory operation.
//
// List all categories.
//
// GET /v1/categories
func (c *Client) ListCategory(ctx context.Context, params ListCategoryParams) (ListCategoryRes, error) {
        res, err := c.sendListCategory(ctx, params)
        return res, err
}

func (c *Client) sendListCategory(ctx context.Context, params ListCategoryParams) (res ListCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/categories"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/categories"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListCurrency invokes listCurrency operation.
//
// List all currencies.
//
// GET /v1/currencies
func (c *Client) ListCurrency(ctx context.Context, params ListCurrencyParams) (ListCurrencyRes, error) {
        res, err := c.sendListCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListCurrency(ctx context.Context, params ListCurrencyParams) (res ListCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/currencies"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListEventByPiggyBank invokes listEventByPiggyBank operation.
//
// List all events linked to a piggy bank (adding and removing money).
//
// GET /v1/piggy-banks/{id}/events
func (c *Client) ListEventByPiggyBank(ctx context.Context, params ListEventByPiggyBankParams) (ListEventByPiggyBankRes, error) {
        res, err := c.sendListEventByPiggyBank(ctx, params)
        return res, err
}

func (c *Client) sendListEventByPiggyBank(ctx context.Context, params ListEventByPiggyBankParams) (res ListEventByPiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listEventByPiggyBank"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks/{id}/events"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListEventByPiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/piggy-banks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/events"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListEventByPiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListEventByPiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListEventByTransaction invokes listEventByTransaction operation.
//
// Lists all piggy bank events.
//
// GET /v1/transactions/{id}/piggy-bank-events
func (c *Client) ListEventByTransaction(ctx context.Context, params ListEventByTransactionParams) (ListEventByTransactionRes, error) {
        res, err := c.sendListEventByTransaction(ctx, params)
        return res, err
}

func (c *Client) sendListEventByTransaction(ctx context.Context, params ListEventByTransactionParams) (res ListEventByTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listEventByTransaction"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transactions/{id}/piggy-bank-events"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListEventByTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/transactions/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/piggy-bank-events"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListEventByTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListEventByTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListLinkType invokes listLinkType operation.
//
// List all the link types the system has. These include the default ones as well as any new ones.
//
// GET /v1/link-types
func (c *Client) ListLinkType(ctx context.Context, params ListLinkTypeParams) (ListLinkTypeRes, error) {
        res, err := c.sendListLinkType(ctx, params)
        return res, err
}

func (c *Client) sendListLinkType(ctx context.Context, params ListLinkTypeParams) (res ListLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listLinkType"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/link-types"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/link-types"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListLinksByJournal invokes listLinksByJournal operation.
//
// Lists all the transaction links for an individual journal (a split). Don't use the group ID, you
// need the actual underlying journal (the split).
//
// GET /v1/transaction-journals/{id}/links
func (c *Client) ListLinksByJournal(ctx context.Context, params ListLinksByJournalParams) (ListLinksByJournalRes, error) {
        res, err := c.sendListLinksByJournal(ctx, params)
        return res, err
}

func (c *Client) sendListLinksByJournal(ctx context.Context, params ListLinksByJournalParams) (res ListLinksByJournalRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listLinksByJournal"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transaction-journals/{id}/links"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListLinksByJournal",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/transaction-journals/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/links"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListLinksByJournal", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListLinksByJournalResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListObjectGroups invokes listObjectGroups operation.
//
// List all oject groups.
//
// GET /v1/object-groups
func (c *Client) ListObjectGroups(ctx context.Context, params ListObjectGroupsParams) (ListObjectGroupsRes, error) {
        res, err := c.sendListObjectGroups(ctx, params)
        return res, err
}

func (c *Client) sendListObjectGroups(ctx context.Context, params ListObjectGroupsParams) (res ListObjectGroupsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listObjectGroups"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/object-groups"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListObjectGroups",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/object-groups"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListObjectGroups", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListObjectGroupsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListPiggyBank invokes listPiggyBank operation.
//
// List all piggy banks.
//
// GET /v1/piggy-banks
func (c *Client) ListPiggyBank(ctx context.Context, params ListPiggyBankParams) (ListPiggyBankRes, error) {
        res, err := c.sendListPiggyBank(ctx, params)
        return res, err
}

func (c *Client) sendListPiggyBank(ctx context.Context, params ListPiggyBankParams) (res ListPiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listPiggyBank"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListPiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListPiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListPiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListPiggyBankByAccount invokes listPiggyBankByAccount operation.
//
// This endpoint returns a list of all the piggy banks connected to the account.
//
// GET /v1/accounts/{id}/piggy-banks
func (c *Client) ListPiggyBankByAccount(ctx context.Context, params ListPiggyBankByAccountParams) (ListPiggyBankByAccountRes, error) {
        res, err := c.sendListPiggyBankByAccount(ctx, params)
        return res, err
}

func (c *Client) sendListPiggyBankByAccount(ctx context.Context, params ListPiggyBankByAccountParams) (res ListPiggyBankByAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listPiggyBankByAccount"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListPiggyBankByAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListPiggyBankByAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListPiggyBankByAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListPiggyBankByObjectGroup invokes listPiggyBankByObjectGroup operation.
//
// This endpoint returns a list of all the piggy banks connected to the object group.
//
// GET /v1/object-groups/{id}/piggy-banks
func (c *Client) ListPiggyBankByObjectGroup(ctx context.Context, params ListPiggyBankByObjectGroupParams) (ListPiggyBankByObjectGroupRes, error) {
        res, err := c.sendListPiggyBankByObjectGroup(ctx, params)
        return res, err
}

func (c *Client) sendListPiggyBankByObjectGroup(ctx context.Context, params ListPiggyBankByObjectGroupParams) (res ListPiggyBankByObjectGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listPiggyBankByObjectGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/object-groups/{id}/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListPiggyBankByObjectGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/object-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListPiggyBankByObjectGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListPiggyBankByObjectGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListPreference invokes listPreference operation.
//
// List all of the preferences of the user.
//
// GET /v1/preferences
func (c *Client) ListPreference(ctx context.Context, params ListPreferenceParams) (ListPreferenceRes, error) {
        res, err := c.sendListPreference(ctx, params)
        return res, err
}

func (c *Client) sendListPreference(ctx context.Context, params ListPreferenceParams) (res ListPreferenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listPreference"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/preferences"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListPreference",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/preferences"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListPreference", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListPreferenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRecurrence invokes listRecurrence operation.
//
// List all recurring transactions.
//
// GET /v1/recurrences
func (c *Client) ListRecurrence(ctx context.Context, params ListRecurrenceParams) (ListRecurrenceRes, error) {
        res, err := c.sendListRecurrence(ctx, params)
        return res, err
}

func (c *Client) sendListRecurrence(ctx context.Context, params ListRecurrenceParams) (res ListRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRecurrence"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/recurrences"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/recurrences"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRecurrenceByCurrency invokes listRecurrenceByCurrency operation.
//
// List all recurring transactions with this currency.
//
// GET /v1/currencies/{code}/recurrences
func (c *Client) ListRecurrenceByCurrency(ctx context.Context, params ListRecurrenceByCurrencyParams) (ListRecurrenceByCurrencyRes, error) {
        res, err := c.sendListRecurrenceByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListRecurrenceByCurrency(ctx context.Context, params ListRecurrenceByCurrencyParams) (res ListRecurrenceByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRecurrenceByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/recurrences"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRecurrenceByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/recurrences"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRecurrenceByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRecurrenceByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRule invokes listRule operation.
//
// List all rules.
//
// GET /v1/rules
func (c *Client) ListRule(ctx context.Context, params ListRuleParams) (ListRuleRes, error) {
        res, err := c.sendListRule(ctx, params)
        return res, err
}

func (c *Client) sendListRule(ctx context.Context, params ListRuleParams) (res ListRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRule"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRuleByBill invokes listRuleByBill operation.
//
// This endpoint will list all rules that have an action to set the bill to this bill.
//
// GET /v1/bills/{id}/rules
func (c *Client) ListRuleByBill(ctx context.Context, params ListRuleByBillParams) (ListRuleByBillRes, error) {
        res, err := c.sendListRuleByBill(ctx, params)
        return res, err
}

func (c *Client) sendListRuleByBill(ctx context.Context, params ListRuleByBillParams) (res ListRuleByBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRuleByBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRuleByBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRuleByBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRuleByBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRuleByCurrency invokes listRuleByCurrency operation.
//
// List all rules with this currency.
//
// GET /v1/currencies/{code}/rules
func (c *Client) ListRuleByCurrency(ctx context.Context, params ListRuleByCurrencyParams) (ListRuleByCurrencyRes, error) {
        res, err := c.sendListRuleByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListRuleByCurrency(ctx context.Context, params ListRuleByCurrencyParams) (res ListRuleByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRuleByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRuleByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRuleByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRuleByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRuleByGroup invokes listRuleByGroup operation.
//
// List rules in this rule group.
//
// GET /v1/rule-groups/{id}/rules
func (c *Client) ListRuleByGroup(ctx context.Context, params ListRuleByGroupParams) (ListRuleByGroupRes, error) {
        res, err := c.sendListRuleByGroup(ctx, params)
        return res, err
}

func (c *Client) sendListRuleByGroup(ctx context.Context, params ListRuleByGroupParams) (res ListRuleByGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRuleByGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}/rules"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRuleByGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRuleByGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRuleByGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListRuleGroup invokes listRuleGroup operation.
//
// List all rule groups.
//
// GET /v1/rule-groups
func (c *Client) ListRuleGroup(ctx context.Context, params ListRuleGroupParams) (ListRuleGroupRes, error) {
        res, err := c.sendListRuleGroup(ctx, params)
        return res, err
}

func (c *Client) sendListRuleGroup(ctx context.Context, params ListRuleGroupParams) (res ListRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listRuleGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rule-groups"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/rule-groups"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTag invokes listTag operation.
//
// List all of the user's tags.
//
// GET /v1/tags
func (c *Client) ListTag(ctx context.Context, params ListTagParams) (ListTagRes, error) {
        res, err := c.sendListTag(ctx, params)
        return res, err
}

func (c *Client) sendListTag(ctx context.Context, params ListTagParams) (res ListTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/tags"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/tags"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransaction invokes listTransaction operation.
//
// List all the user's transactions.
//
// GET /v1/transactions
func (c *Client) ListTransaction(ctx context.Context, params ListTransactionParams) (ListTransactionRes, error) {
        res, err := c.sendListTransaction(ctx, params)
        return res, err
}

func (c *Client) sendListTransaction(ctx context.Context, params ListTransactionParams) (res ListTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransaction"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByAccount invokes listTransactionByAccount operation.
//
// This endpoint returns a list of all the transactions connected to the account.
//
// GET /v1/accounts/{id}/transactions
func (c *Client) ListTransactionByAccount(ctx context.Context, params ListTransactionByAccountParams) (ListTransactionByAccountRes, error) {
        res, err := c.sendListTransactionByAccount(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByAccount(ctx context.Context, params ListTransactionByAccountParams) (res ListTransactionByAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByAccount"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByBill invokes listTransactionByBill operation.
//
// This endpoint will list all transactions linked to this bill.
//
// GET /v1/bills/{id}/transactions
func (c *Client) ListTransactionByBill(ctx context.Context, params ListTransactionByBillParams) (ListTransactionByBillRes, error) {
        res, err := c.sendListTransactionByBill(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByBill(ctx context.Context, params ListTransactionByBillParams) (res ListTransactionByBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByBill"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByBudget invokes listTransactionByBudget operation.
//
// Get all transactions linked to a budget, possibly limited by start and end.
//
// GET /v1/budgets/{id}/transactions
func (c *Client) ListTransactionByBudget(ctx context.Context, params ListTransactionByBudgetParams) (ListTransactionByBudgetRes, error) {
        res, err := c.sendListTransactionByBudget(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByBudget(ctx context.Context, params ListTransactionByBudgetParams) (res ListTransactionByBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByBudget"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Limit.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByBudgetLimit invokes listTransactionByBudgetLimit operation.
//
// List all the transactions within one budget limit. The start and end date are dictated by the
// budget limit.
//
// GET /v1/budgets/{id}/limits/{limitId}/transactions
func (c *Client) ListTransactionByBudgetLimit(ctx context.Context, params ListTransactionByBudgetLimitParams) (ListTransactionByBudgetLimitRes, error) {
        res, err := c.sendListTransactionByBudgetLimit(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByBudgetLimit(ctx context.Context, params ListTransactionByBudgetLimitParams) (res ListTransactionByBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByBudgetLimit"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits/{limitId}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [5]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits/"
        {
                // Encode "limitId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "limitId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.LimitId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        pathParts[4] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByCategory invokes listTransactionByCategory operation.
//
// List all transactions in a category, optionally limited to the date ranges specified.
//
// GET /v1/categories/{id}/transactions
func (c *Client) ListTransactionByCategory(ctx context.Context, params ListTransactionByCategoryParams) (ListTransactionByCategoryRes, error) {
        res, err := c.sendListTransactionByCategory(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByCategory(ctx context.Context, params ListTransactionByCategoryParams) (res ListTransactionByCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByCategory"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/categories/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/categories/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByCurrency invokes listTransactionByCurrency operation.
//
// List all transactions with this currency.
//
// GET /v1/currencies/{code}/transactions
func (c *Client) ListTransactionByCurrency(ctx context.Context, params ListTransactionByCurrencyParams) (ListTransactionByCurrencyRes, error) {
        res, err := c.sendListTransactionByCurrency(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByCurrency(ctx context.Context, params ListTransactionByCurrencyParams) (res ListTransactionByCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByCurrency"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByLinkType invokes listTransactionByLinkType operation.
//
// List all transactions under this link type, both the inward and outward transactions.
//
// GET /v1/link-types/{id}/transactions
func (c *Client) ListTransactionByLinkType(ctx context.Context, params ListTransactionByLinkTypeParams) (ListTransactionByLinkTypeRes, error) {
        res, err := c.sendListTransactionByLinkType(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByLinkType(ctx context.Context, params ListTransactionByLinkTypeParams) (res ListTransactionByLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByLinkType"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/link-types/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/link-types/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByRecurrence invokes listTransactionByRecurrence operation.
//
// List all transactions created by a recurring transaction, optionally limited to the date ranges
// specified.
//
// GET /v1/recurrences/{id}/transactions
func (c *Client) ListTransactionByRecurrence(ctx context.Context, params ListTransactionByRecurrenceParams) (ListTransactionByRecurrenceRes, error) {
        res, err := c.sendListTransactionByRecurrence(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByRecurrence(ctx context.Context, params ListTransactionByRecurrenceParams) (res ListTransactionByRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByRecurrence"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/recurrences/{id}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/recurrences/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionByTag invokes listTransactionByTag operation.
//
// List all transactions with this tag.
//
// GET /v1/tags/{tag}/transactions
func (c *Client) ListTransactionByTag(ctx context.Context, params ListTransactionByTagParams) (ListTransactionByTagRes, error) {
        res, err := c.sendListTransactionByTag(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionByTag(ctx context.Context, params ListTransactionByTagParams) (res ListTransactionByTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionByTag"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/tags/{tag}/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionByTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/tags/"
        {
                // Encode "tag" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "tag",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Tag))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionByTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionByTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListTransactionLink invokes listTransactionLink operation.
//
// List all the transaction links.
//
// GET /v1/transaction-links
func (c *Client) ListTransactionLink(ctx context.Context, params ListTransactionLinkParams) (ListTransactionLinkRes, error) {
        res, err := c.sendListTransactionLink(ctx, params)
        return res, err
}

func (c *Client) sendListTransactionLink(ctx context.Context, params ListTransactionLinkParams) (res ListTransactionLinkRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listTransactionLink"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/transaction-links"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListTransactionLink",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/transaction-links"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListTransactionLink", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListTransactionLinkResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListUser invokes listUser operation.
//
// List all the users in this instance of Firefly III.
//
// GET /v1/users
func (c *Client) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) {
        res, err := c.sendListUser(ctx, params)
        return res, err
}

func (c *Client) sendListUser(ctx context.Context, params ListUserParams) (res ListUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listUser"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/users"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/users"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// ListWebhook invokes listWebhook operation.
//
// List all the user's webhooks.
//
// GET /v1/webhooks
func (c *Client) ListWebhook(ctx context.Context, params ListWebhookParams) (ListWebhookRes, error) {
        res, err := c.sendListWebhook(ctx, params)
        return res, err
}

func (c *Client) sendListWebhook(ctx context.Context, params ListWebhookParams) (res ListWebhookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("listWebhook"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/webhooks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "ListWebhook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/webhooks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "ListWebhook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeListWebhookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// PurgeData invokes purgeData operation.
//
// A call to this endpoint purges all previously deleted data. Use it with care and always with user
// permission.
// The demo user is incapable of using this endpoint.
//
// DELETE /v1/data/purge
func (c *Client) PurgeData(ctx context.Context, params PurgeDataParams) (PurgeDataRes, error) {
        res, err := c.sendPurgeData(ctx, params)
        return res, err
}

func (c *Client) sendPurgeData(ctx context.Context, params PurgeDataParams) (res PurgeDataRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("purgeData"),
                semconv.HTTPMethodKey.String("DELETE"),
                semconv.HTTPRouteKey.String("/v1/data/purge"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "PurgeData",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/data/purge"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "DELETE", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "PurgeData", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodePurgeDataResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// SearchAccounts invokes searchAccounts operation.
//
// Search for accounts.
//
// GET /v1/search/accounts
func (c *Client) SearchAccounts(ctx context.Context, params SearchAccountsParams) (SearchAccountsRes, error) {
        res, err := c.sendSearchAccounts(ctx, params)
        return res, err
}

func (c *Client) sendSearchAccounts(ctx context.Context, params SearchAccountsParams) (res SearchAccountsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("searchAccounts"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/search/accounts"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "SearchAccounts",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/search/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.StringToString(params.Query))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "type" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "type",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Type.Get(); ok {
                                return e.EncodeValue(conv.StringToString(string(val)))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "field" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "field",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.StringToString(string(params.Field)))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "SearchAccounts", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeSearchAccountsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// SearchTransactions invokes searchTransactions operation.
//
// Searches through the users transactions.
//
// GET /v1/search/transactions
func (c *Client) SearchTransactions(ctx context.Context, params SearchTransactionsParams) (SearchTransactionsRes, error) {
        res, err := c.sendSearchTransactions(ctx, params)
        return res, err
}

func (c *Client) sendSearchTransactions(ctx context.Context, params SearchTransactionsParams) (res SearchTransactionsRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("searchTransactions"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/search/transactions"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "SearchTransactions",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/search/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "query" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "query",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeValue(conv.StringToString(params.Query))
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "SearchTransactions", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeSearchTransactionsResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// SetConfiguration invokes setConfiguration operation.
//
// Set a single configuration value. Not all configuration values can be updated so the list of
// accepted configuration variables is small.
//
// PUT /v1/configuration/{name}
func (c *Client) SetConfiguration(ctx context.Context, request *ConfigurationUpdate, params SetConfigurationParams) (SetConfigurationRes, error) {
        res, err := c.sendSetConfiguration(ctx, request, params)
        return res, err
}

func (c *Client) sendSetConfiguration(ctx context.Context, request *ConfigurationUpdate, params SetConfigurationParams) (res SetConfigurationRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("setConfiguration"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/configuration/{name}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "SetConfiguration",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/configuration/"
        {
                // Encode "name" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "name",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(string(params.Name)))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeSetConfigurationRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "SetConfiguration", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeSetConfigurationResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreAccount invokes storeAccount operation.
//
// Creates a new account. The data required can be submitted as a JSON body or as a list of
// parameters (in key=value pairs, like a webform).
//
// POST /v1/accounts
func (c *Client) StoreAccount(ctx context.Context, request *AccountStore, params StoreAccountParams) (StoreAccountRes, error) {
        res, err := c.sendStoreAccount(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreAccount(ctx context.Context, request *AccountStore, params StoreAccountParams) (res StoreAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeAccount"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/accounts"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/accounts"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreAccountRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreAttachment invokes storeAttachment operation.
//
// Creates a new attachment. The data required can be submitted as a JSON body or as a list of
// parameters. You cannot use this endpoint to upload the actual file data (see below). This endpoint
// only creates the attachment object.
//
// POST /v1/attachments
func (c *Client) StoreAttachment(ctx context.Context, request *AttachmentStore, params StoreAttachmentParams) (StoreAttachmentRes, error) {
        res, err := c.sendStoreAttachment(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreAttachment(ctx context.Context, request *AttachmentStore, params StoreAttachmentParams) (res StoreAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeAttachment"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/attachments"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/attachments"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreAttachmentRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreBill invokes storeBill operation.
//
// Creates a new bill. The data required can be submitted as a JSON body or as a list of parameters.
//
// POST /v1/bills
func (c *Client) StoreBill(ctx context.Context, request *BillStore, params StoreBillParams) (StoreBillRes, error) {
        res, err := c.sendStoreBill(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreBill(ctx context.Context, request *BillStore, params StoreBillParams) (res StoreBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeBill"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/bills"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/bills"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreBillRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreBudget invokes storeBudget operation.
//
// Creates a new budget. The data required can be submitted as a JSON body or as a list of parameters.
//
// POST /v1/budgets
func (c *Client) StoreBudget(ctx context.Context, request *BudgetStore, params StoreBudgetParams) (StoreBudgetRes, error) {
        res, err := c.sendStoreBudget(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreBudget(ctx context.Context, request *BudgetStore, params StoreBudgetParams) (res StoreBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeBudget"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/budgets"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/budgets"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreBudgetRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreBudgetLimit invokes storeBudgetLimit operation.
//
// Store a new budget limit under this budget.
//
// POST /v1/budgets/{id}/limits
func (c *Client) StoreBudgetLimit(ctx context.Context, request *BudgetLimitStore, params StoreBudgetLimitParams) (StoreBudgetLimitRes, error) {
        res, err := c.sendStoreBudgetLimit(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreBudgetLimit(ctx context.Context, request *BudgetLimitStore, params StoreBudgetLimitParams) (res StoreBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeBudgetLimit"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreBudgetLimitRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreCategory invokes storeCategory operation.
//
// Creates a new category. The data required can be submitted as a JSON body or as a list of
// parameters.
//
// POST /v1/categories
func (c *Client) StoreCategory(ctx context.Context, request *Category, params StoreCategoryParams) (StoreCategoryRes, error) {
        res, err := c.sendStoreCategory(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreCategory(ctx context.Context, request *Category, params StoreCategoryParams) (res StoreCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeCategory"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/categories"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/categories"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreCategoryRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreCurrency invokes storeCurrency operation.
//
// Creates a new currency. The data required can be submitted as a JSON body or as a list of
// parameters.
//
// POST /v1/currencies
func (c *Client) StoreCurrency(ctx context.Context, request *CurrencyStore, params StoreCurrencyParams) (StoreCurrencyRes, error) {
        res, err := c.sendStoreCurrency(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreCurrency(ctx context.Context, request *CurrencyStore, params StoreCurrencyParams) (res StoreCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeCurrency"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/currencies"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/currencies"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreCurrencyRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreLinkType invokes storeLinkType operation.
//
// Creates a new link type. The data required can be submitted as a JSON body or as a list of
// parameters (in key=value pairs, like a webform).
//
// POST /v1/link-types
func (c *Client) StoreLinkType(ctx context.Context, request *LinkType, params StoreLinkTypeParams) (StoreLinkTypeRes, error) {
        res, err := c.sendStoreLinkType(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreLinkType(ctx context.Context, request *LinkType, params StoreLinkTypeParams) (res StoreLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeLinkType"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/link-types"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/link-types"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreLinkTypeRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StorePiggyBank invokes storePiggyBank operation.
//
// Creates a new piggy bank. The data required can be submitted as a JSON body or as a list of
// parameters.
//
// POST /v1/piggy-banks
func (c *Client) StorePiggyBank(ctx context.Context, request *PiggyBankStore, params StorePiggyBankParams) (StorePiggyBankRes, error) {
        res, err := c.sendStorePiggyBank(ctx, request, params)
        return res, err
}

func (c *Client) sendStorePiggyBank(ctx context.Context, request *PiggyBankStore, params StorePiggyBankParams) (res StorePiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storePiggyBank"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StorePiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/piggy-banks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStorePiggyBankRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StorePiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStorePiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StorePreference invokes storePreference operation.
//
// This endpoint creates a new preference. The name and data are free-format, and entirely up to you.
// If the preference is not used in Firefly III itself it may not be configurable through the user
// interface, but you can use this endpoint to persist custom data for your own app.
//
// POST /v1/preferences
func (c *Client) StorePreference(ctx context.Context, request *Preference, params StorePreferenceParams) (StorePreferenceRes, error) {
        res, err := c.sendStorePreference(ctx, request, params)
        return res, err
}

func (c *Client) sendStorePreference(ctx context.Context, request *Preference, params StorePreferenceParams) (res StorePreferenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storePreference"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/preferences"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StorePreference",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/preferences"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStorePreferenceRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StorePreference", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStorePreferenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreRecurrence invokes storeRecurrence operation.
//
// Creates a new recurring transaction. The data required can be submitted as a JSON body or as a
// list of parameters.
//
// POST /v1/recurrences
func (c *Client) StoreRecurrence(ctx context.Context, request *RecurrenceStore, params StoreRecurrenceParams) (StoreRecurrenceRes, error) {
        res, err := c.sendStoreRecurrence(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreRecurrence(ctx context.Context, request *RecurrenceStore, params StoreRecurrenceParams) (res StoreRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeRecurrence"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/recurrences"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/recurrences"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreRecurrenceRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreRule invokes storeRule operation.
//
// Creates a new rule. The data required can be submitted as a JSON body or as a list of parameters.
//
// POST /v1/rules
func (c *Client) StoreRule(ctx context.Context, request *RuleStore, params StoreRuleParams) (StoreRuleRes, error) {
        res, err := c.sendStoreRule(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreRule(ctx context.Context, request *RuleStore, params StoreRuleParams) (res StoreRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeRule"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/rules"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/rules"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreRuleRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreRuleGroup invokes storeRuleGroup operation.
//
// Creates a new rule group. The data required can be submitted as a JSON body or as a list of
// parameters.
//
// POST /v1/rule-groups
func (c *Client) StoreRuleGroup(ctx context.Context, request *RuleGroupStore, params StoreRuleGroupParams) (StoreRuleGroupRes, error) {
        res, err := c.sendStoreRuleGroup(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreRuleGroup(ctx context.Context, request *RuleGroupStore, params StoreRuleGroupParams) (res StoreRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeRuleGroup"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/rule-groups"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/rule-groups"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreRuleGroupRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreTag invokes storeTag operation.
//
// Creates a new tag. The data required can be submitted as a JSON body or as a list of parameters.
//
// POST /v1/tags
func (c *Client) StoreTag(ctx context.Context, request *TagModelStore, params StoreTagParams) (StoreTagRes, error) {
        res, err := c.sendStoreTag(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreTag(ctx context.Context, request *TagModelStore, params StoreTagParams) (res StoreTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeTag"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/tags"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/tags"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreTagRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreTransaction invokes storeTransaction operation.
//
// Creates a new transaction. The data required can be submitted as a JSON body or as a list of
// parameters.
//
// POST /v1/transactions
func (c *Client) StoreTransaction(ctx context.Context, request *TransactionStore, params StoreTransactionParams) (StoreTransactionRes, error) {
        res, err := c.sendStoreTransaction(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreTransaction(ctx context.Context, request *TransactionStore, params StoreTransactionParams) (res StoreTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeTransaction"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/transactions"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/transactions"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreTransactionRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreTransactionLink invokes storeTransactionLink operation.
//
// Store a new link between two transactions. For this end point you need the journal_id from a
// transaction.
//
// POST /v1/transaction-links
func (c *Client) StoreTransactionLink(ctx context.Context, request *TransactionLinkStore, params StoreTransactionLinkParams) (StoreTransactionLinkRes, error) {
        res, err := c.sendStoreTransactionLink(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreTransactionLink(ctx context.Context, request *TransactionLinkStore, params StoreTransactionLinkParams) (res StoreTransactionLinkRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeTransactionLink"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/transaction-links"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreTransactionLink",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/transaction-links"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreTransactionLinkRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreTransactionLink", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreTransactionLinkResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreUser invokes storeUser operation.
//
// Creates a new user. The data required can be submitted as a JSON body or as a list of parameters.
// The user will be given a random password, which they can reset using the "forgot password"
// function.
//
// POST /v1/users
func (c *Client) StoreUser(ctx context.Context, request *User, params StoreUserParams) (StoreUserRes, error) {
        res, err := c.sendStoreUser(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreUser(ctx context.Context, request *User, params StoreUserParams) (res StoreUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeUser"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/users"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/users"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreUserRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// StoreWebhook invokes storeWebhook operation.
//
// Creates a new webhook. The data required can be submitted as a JSON body or as a list of
// parameters. The webhook will be given a random secret.
//
// POST /v1/webhooks
func (c *Client) StoreWebhook(ctx context.Context, request *WebhookStore, params StoreWebhookParams) (StoreWebhookRes, error) {
        res, err := c.sendStoreWebhook(ctx, request, params)
        return res, err
}

func (c *Client) sendStoreWebhook(ctx context.Context, request *WebhookStore, params StoreWebhookParams) (res StoreWebhookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("storeWebhook"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/webhooks"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "StoreWebhook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [1]string
        pathParts[0] = "/v1/webhooks"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeStoreWebhookRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "StoreWebhook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeStoreWebhookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// SubmitWebook invokes submitWebook operation.
//
// This endpoint will submit any open messages for this webhook. This is an asynchronous operation,
// so you can't see the result. Refresh the webhook message and/or the webhook message attempts to
// see the results. This may take some time if the webhook receiver is slow.
//
// POST /v1/webhooks/{id}/submit
func (c *Client) SubmitWebook(ctx context.Context, params SubmitWebookParams) (SubmitWebookRes, error) {
        res, err := c.sendSubmitWebook(ctx, params)
        return res, err
}

func (c *Client) sendSubmitWebook(ctx context.Context, params SubmitWebookParams) (res SubmitWebookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("submitWebook"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}/submit"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "SubmitWebook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/submit"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "SubmitWebook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeSubmitWebookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// TestRule invokes testRule operation.
//
// Test which transactions would be hit by the rule. No changes will be made. Limit the result if you
// want to.
//
// GET /v1/rules/{id}/test
func (c *Client) TestRule(ctx context.Context, params TestRuleParams) (TestRuleRes, error) {
        res, err := c.sendTestRule(ctx, params)
        return res, err
}

func (c *Client) sendTestRule(ctx context.Context, params TestRuleParams) (res TestRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("testRule"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rules/{id}/test"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "TestRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/rules/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/test"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "TestRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeTestRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// TestRuleGroup invokes testRuleGroup operation.
//
// Test which transactions would be hit by the rule group. No changes will be made. Limit the result
// if you want to.
//
// GET /v1/rule-groups/{id}/test
func (c *Client) TestRuleGroup(ctx context.Context, params TestRuleGroupParams) (TestRuleGroupRes, error) {
        res, err := c.sendTestRuleGroup(ctx, params)
        return res, err
}

func (c *Client) sendTestRuleGroup(ctx context.Context, params TestRuleGroupParams) (res TestRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("testRuleGroup"),
                semconv.HTTPMethodKey.String("GET"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}/test"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "TestRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/test"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeQueryParams"
        q := uri.NewQueryEncoder()
        {
                // Encode "page" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "page",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Page.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "start" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "start",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.Start.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "end" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "end",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.End.Get(); ok {
                                return e.EncodeValue(conv.DateToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "search_limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "search_limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.SearchLimit.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "triggered_limit" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "triggered_limit",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.TriggeredLimit.Get(); ok {
                                return e.EncodeValue(conv.IntToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        {
                // Encode "accounts[]" parameter.
                cfg := uri.QueryParameterEncodingConfig{
                        Name:    "accounts[]",
                        Style:   uri.QueryStyleForm,
                        Explode: true,
                }

                if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
                        return e.EncodeArray(func(e uri.Encoder) error {
                                for i, item := range params.Accounts {
                                        if err := func() error {
                                                return e.EncodeValue(conv.Int64ToString(item))
                                        }(); err != nil {
                                                return errors.Wrapf(err, "[%d]", i)
                                        }
                                }
                                return nil
                        })
                }); err != nil {
                        return res, errors.Wrap(err, "encode query")
                }
        }
        u.RawQuery = q.Values().Encode()

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "GET", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "TestRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeTestRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateAccount invokes updateAccount operation.
//
// Used to update a single account. All fields that are not submitted will be cleared (set to NULL).
// The model will tell you which fields are mandatory.
//
// PUT /v1/accounts/{id}
func (c *Client) UpdateAccount(ctx context.Context, request *AccountUpdate, params UpdateAccountParams) (UpdateAccountRes, error) {
        res, err := c.sendUpdateAccount(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateAccount(ctx context.Context, request *AccountUpdate, params UpdateAccountParams) (res UpdateAccountRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateAccount"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/accounts/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateAccount",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/accounts/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateAccountRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateAccount", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateAccountResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateAttachment invokes updateAttachment operation.
//
// Update the meta data for an existing attachment. This endpoint does not allow you to upload or
// download data. For that, see below.
//
// PUT /v1/attachments/{id}
func (c *Client) UpdateAttachment(ctx context.Context, request *AttachmentUpdate, params UpdateAttachmentParams) (UpdateAttachmentRes, error) {
        res, err := c.sendUpdateAttachment(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateAttachment(ctx context.Context, request *AttachmentUpdate, params UpdateAttachmentParams) (res UpdateAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateAttachment"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/attachments/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/attachments/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateAttachmentRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateBill invokes updateBill operation.
//
// Update existing bill.
//
// PUT /v1/bills/{id}
func (c *Client) UpdateBill(ctx context.Context, request *BillUpdate, params UpdateBillParams) (UpdateBillRes, error) {
        res, err := c.sendUpdateBill(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateBill(ctx context.Context, request *BillUpdate, params UpdateBillParams) (res UpdateBillRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateBill"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/bills/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateBill",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/bills/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateBillRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateBill", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateBillResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateBudget invokes updateBudget operation.
//
// Update existing budget. This endpoint cannot be used to set budget amount limits.
//
// PUT /v1/budgets/{id}
func (c *Client) UpdateBudget(ctx context.Context, request *BudgetUpdate, params UpdateBudgetParams) (UpdateBudgetRes, error) {
        res, err := c.sendUpdateBudget(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateBudget(ctx context.Context, request *BudgetUpdate, params UpdateBudgetParams) (res UpdateBudgetRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateBudget"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateBudget",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateBudgetRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateBudget", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateBudgetResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateBudgetLimit invokes updateBudgetLimit operation.
//
// Update existing budget limit.
//
// PUT /v1/budgets/{id}/limits/{limitId}
func (c *Client) UpdateBudgetLimit(ctx context.Context, request *BudgetLimit, params UpdateBudgetLimitParams) (UpdateBudgetLimitRes, error) {
        res, err := c.sendUpdateBudgetLimit(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateBudgetLimit(ctx context.Context, request *BudgetLimit, params UpdateBudgetLimitParams) (res UpdateBudgetLimitRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateBudgetLimit"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/budgets/{id}/limits/{limitId}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateBudgetLimit",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [4]string
        pathParts[0] = "/v1/budgets/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/limits/"
        {
                // Encode "limitId" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "limitId",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.LimitId))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[3] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateBudgetLimitRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateBudgetLimit", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateBudgetLimitResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateCategory invokes updateCategory operation.
//
// Update existing category.
//
// PUT /v1/categories/{id}
func (c *Client) UpdateCategory(ctx context.Context, request *CategoryUpdate, params UpdateCategoryParams) (UpdateCategoryRes, error) {
        res, err := c.sendUpdateCategory(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateCategory(ctx context.Context, request *CategoryUpdate, params UpdateCategoryParams) (res UpdateCategoryRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateCategory"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/categories/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateCategory",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/categories/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateCategoryRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateCategory", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateCategoryResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateCurrency invokes updateCurrency operation.
//
// Update existing currency.
//
// PUT /v1/currencies/{code}
func (c *Client) UpdateCurrency(ctx context.Context, request *CurrencyUpdate, params UpdateCurrencyParams) (UpdateCurrencyRes, error) {
        res, err := c.sendUpdateCurrency(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateCurrency(ctx context.Context, request *CurrencyUpdate, params UpdateCurrencyParams) (res UpdateCurrencyRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateCurrency"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/currencies/{code}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateCurrency",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/currencies/"
        {
                // Encode "code" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "code",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Code))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateCurrencyRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateCurrency", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateCurrencyResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateLinkType invokes updateLinkType operation.
//
// Used to update a single link type. All fields that are not submitted will be cleared (set to NULL).
//
//        The model will tell you which fields are mandatory. You cannot update some of the system provided
//
// link types, indicated by the editable=false flag when you list it.
//
// PUT /v1/link-types/{id}
func (c *Client) UpdateLinkType(ctx context.Context, request *LinkTypeUpdate, params UpdateLinkTypeParams) (UpdateLinkTypeRes, error) {
        res, err := c.sendUpdateLinkType(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateLinkType(ctx context.Context, request *LinkTypeUpdate, params UpdateLinkTypeParams) (res UpdateLinkTypeRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateLinkType"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/link-types/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateLinkType",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/link-types/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateLinkTypeRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateLinkType", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateLinkTypeResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateObjectGroup invokes updateObjectGroup operation.
//
// Update existing object group.
//
// PUT /v1/object-groups/{id}
func (c *Client) UpdateObjectGroup(ctx context.Context, request *ObjectGroupUpdate, params UpdateObjectGroupParams) (UpdateObjectGroupRes, error) {
        res, err := c.sendUpdateObjectGroup(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateObjectGroup(ctx context.Context, request *ObjectGroupUpdate, params UpdateObjectGroupParams) (res UpdateObjectGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateObjectGroup"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/object-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateObjectGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/object-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateObjectGroupRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateObjectGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateObjectGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdatePiggyBank invokes updatePiggyBank operation.
//
// Update existing piggy bank.
//
// PUT /v1/piggy-banks/{id}
func (c *Client) UpdatePiggyBank(ctx context.Context, request *PiggyBankUpdate, params UpdatePiggyBankParams) (UpdatePiggyBankRes, error) {
        res, err := c.sendUpdatePiggyBank(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdatePiggyBank(ctx context.Context, request *PiggyBankUpdate, params UpdatePiggyBankParams) (res UpdatePiggyBankRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updatePiggyBank"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/piggy-banks/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdatePiggyBank",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/piggy-banks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdatePiggyBankRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdatePiggyBank", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdatePiggyBankResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdatePreference invokes updatePreference operation.
//
// Update a user's preference.
//
// PUT /v1/preferences/{name}
func (c *Client) UpdatePreference(ctx context.Context, request *PreferenceUpdate, params UpdatePreferenceParams) (UpdatePreferenceRes, error) {
        res, err := c.sendUpdatePreference(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdatePreference(ctx context.Context, request *PreferenceUpdate, params UpdatePreferenceParams) (res UpdatePreferenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updatePreference"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/preferences/{name}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdatePreference",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/preferences/"
        {
                // Encode "name" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "name",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Name))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdatePreferenceRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdatePreference", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdatePreferenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateRecurrence invokes updateRecurrence operation.
//
// Update existing recurring transaction.
//
// PUT /v1/recurrences/{id}
func (c *Client) UpdateRecurrence(ctx context.Context, request *RecurrenceUpdate, params UpdateRecurrenceParams) (UpdateRecurrenceRes, error) {
        res, err := c.sendUpdateRecurrence(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateRecurrence(ctx context.Context, request *RecurrenceUpdate, params UpdateRecurrenceParams) (res UpdateRecurrenceRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateRecurrence"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/recurrences/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateRecurrence",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/recurrences/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateRecurrenceRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateRecurrence", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateRecurrenceResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateRule invokes updateRule operation.
//
// Update existing rule.
//
// PUT /v1/rules/{id}
func (c *Client) UpdateRule(ctx context.Context, request *RuleUpdate, params UpdateRuleParams) (UpdateRuleRes, error) {
        res, err := c.sendUpdateRule(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateRule(ctx context.Context, request *RuleUpdate, params UpdateRuleParams) (res UpdateRuleRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateRule"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/rules/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateRule",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rules/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateRuleRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateRule", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateRuleResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateRuleGroup invokes updateRuleGroup operation.
//
// Update existing rule group.
//
// PUT /v1/rule-groups/{id}
func (c *Client) UpdateRuleGroup(ctx context.Context, request *RuleGroupUpdate, params UpdateRuleGroupParams) (UpdateRuleGroupRes, error) {
        res, err := c.sendUpdateRuleGroup(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateRuleGroup(ctx context.Context, request *RuleGroupUpdate, params UpdateRuleGroupParams) (res UpdateRuleGroupRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateRuleGroup"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/rule-groups/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateRuleGroup",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/rule-groups/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateRuleGroupRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateRuleGroup", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateRuleGroupResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateTag invokes updateTag operation.
//
// Update existing tag.
//
// PUT /v1/tags/{tag}
func (c *Client) UpdateTag(ctx context.Context, request *TagModelUpdate, params UpdateTagParams) (UpdateTagRes, error) {
        res, err := c.sendUpdateTag(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateTag(ctx context.Context, request *TagModelUpdate, params UpdateTagParams) (res UpdateTagRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateTag"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/tags/{tag}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateTag",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/tags/"
        {
                // Encode "tag" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "tag",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.Tag))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateTagRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateTag", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateTagResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateTransaction invokes updateTransaction operation.
//
// Update an existing transaction.
//
// PUT /v1/transactions/{id}
func (c *Client) UpdateTransaction(ctx context.Context, request *TransactionUpdate, params UpdateTransactionParams) (UpdateTransactionRes, error) {
        res, err := c.sendUpdateTransaction(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateTransaction(ctx context.Context, request *TransactionUpdate, params UpdateTransactionParams) (res UpdateTransactionRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateTransaction"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/transactions/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateTransaction",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transactions/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateTransactionRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateTransaction", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateTransactionResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateTransactionLink invokes updateTransactionLink operation.
//
// Used to update a single existing link.
//
// PUT /v1/transaction-links/{id}
func (c *Client) UpdateTransactionLink(ctx context.Context, request *TransactionLinkUpdate, params UpdateTransactionLinkParams) (UpdateTransactionLinkRes, error) {
        res, err := c.sendUpdateTransactionLink(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateTransactionLink(ctx context.Context, request *TransactionLinkUpdate, params UpdateTransactionLinkParams) (res UpdateTransactionLinkRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateTransactionLink"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/transaction-links/{id}"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateTransactionLink",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/transaction-links/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateTransactionLinkRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateTransactionLink", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateTransactionLinkResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateUser invokes updateUser operation.
//
// Update existing user.
//
// PUT /v1/users/{id}
func (c *Client) UpdateUser(ctx context.Context, request *User, params UpdateUserParams) (UpdateUserRes, error) {
        res, err := c.sendUpdateUser(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateUser(ctx context.Context, request *User, params UpdateUserParams) (res UpdateUserRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateUser"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/users/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateUser",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/users/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateUserRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateUser", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateUserResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UpdateWebhook invokes updateWebhook operation.
//
// Update an existing webhook's information. If you wish to reset the secret, submit any value as the
// "secret". Firefly III will take this as a hint and reset the secret of the webhook.
//
// PUT /v1/webhooks/{id}
func (c *Client) UpdateWebhook(ctx context.Context, request *WebhookUpdate, params UpdateWebhookParams) (UpdateWebhookRes, error) {
        res, err := c.sendUpdateWebhook(ctx, request, params)
        return res, err
}

func (c *Client) sendUpdateWebhook(ctx context.Context, request *WebhookUpdate, params UpdateWebhookParams) (res UpdateWebhookRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("updateWebhook"),
                semconv.HTTPMethodKey.String("PUT"),
                semconv.HTTPRouteKey.String("/v1/webhooks/{id}"),
        }
        // Validate request before sending.
        if err := func() error {
                if err := request.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return res, errors.Wrap(err, "validate")
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UpdateWebhook",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [2]string
        pathParts[0] = "/v1/webhooks/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "PUT", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUpdateWebhookRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UpdateWebhook", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUpdateWebhookResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// UploadAttachment invokes uploadAttachment operation.
//
// Use this endpoint to upload (and possible overwrite) the file contents of an attachment. Simply
// put the entire file in the body as binary data.
//
// POST /v1/attachments/{id}/upload
func (c *Client) UploadAttachment(ctx context.Context, request UploadAttachmentReq, params UploadAttachmentParams) (UploadAttachmentRes, error) {
        res, err := c.sendUploadAttachment(ctx, request, params)
        return res, err
}

func (c *Client) sendUploadAttachment(ctx context.Context, request UploadAttachmentReq, params UploadAttachmentParams) (res UploadAttachmentRes, err error) {
        otelAttrs := []attribute.KeyValue{
                otelogen.OperationID("uploadAttachment"),
                semconv.HTTPMethodKey.String("POST"),
                semconv.HTTPRouteKey.String("/v1/attachments/{id}/upload"),
        }

        // Run stopwatch.
        startTime := time.Now()
        defer func() {
                // Use floating point division here for higher precision (instead of Millisecond method).
                elapsedDuration := time.Since(startTime)
                c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
        }()

        // Increment request counter.
        c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

        // Start a span for this request.
        ctx, span := c.cfg.Tracer.Start(ctx, "UploadAttachment",
                trace.WithAttributes(otelAttrs...),
                clientSpanKind,
        )
        // Track stage for error reporting.
        var stage string
        defer func() {
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, stage)
                        c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
                }
                span.End()
        }()

        stage = "BuildURL"
        u := uri.Clone(c.requestURL(ctx))
        var pathParts [3]string
        pathParts[0] = "/v1/attachments/"
        {
                // Encode "id" parameter.
                e := uri.NewPathEncoder(uri.PathEncoderConfig{
                        Param:   "id",
                        Style:   uri.PathStyleSimple,
                        Explode: false,
                })
                if err := func() error {
                        return e.EncodeValue(conv.StringToString(params.ID))
                }(); err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                encoded, err := e.Result()
                if err != nil {
                        return res, errors.Wrap(err, "encode path")
                }
                pathParts[1] = encoded
        }
        pathParts[2] = "/upload"
        uri.AddPathParts(u, pathParts[:]...)

        stage = "EncodeRequest"
        r, err := ht.NewRequest(ctx, "POST", u)
        if err != nil {
                return res, errors.Wrap(err, "create request")
        }
        if err := encodeUploadAttachmentRequest(request, r); err != nil {
                return res, errors.Wrap(err, "encode request")
        }

        stage = "EncodeHeaderParams"
        h := uri.NewHeaderEncoder(r.Header)
        {
                cfg := uri.HeaderParameterEncodingConfig{
                        Name:    "X-Trace-Id",
                        Explode: false,
                }
                if err := h.EncodeParam(cfg, func(e uri.Encoder) error {
                        if val, ok := params.XTraceID.Get(); ok {
                                return e.EncodeValue(conv.UUIDToString(val))
                        }
                        return nil
                }); err != nil {
                        return res, errors.Wrap(err, "encode header")
                }
        }

        {
                type bitset = [1]uint8
                var satisfied bitset
                {
                        stage = "Security:FireflyIiiAuth"
                        switch err := c.securityFireflyIiiAuth(ctx, "UploadAttachment", r); {
                        case err == nil: // if NO error
                                satisfied[0] |= 1 << 0
                        case errors.Is(err, ogenerrors.ErrSkipClientSecurity):
                                // Skip this security.
                        default:
                                return res, errors.Wrap(err, "security \"FireflyIiiAuth\"")
                        }
                }

                if ok := func() bool {
                nextRequirement:
                        for _, requirement := range []bitset{
                                {0b00000001},
                        } {
                                for i, mask := range requirement {
                                        if satisfied[i]&mask != mask {
                                                continue nextRequirement
                                        }
                                }
                                return true
                        }
                        return false
                }(); !ok {
                        return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied
                }
        }

        stage = "SendRequest"
        resp, err := c.cfg.Client.Do(r)
        if err != nil {
                return res, errors.Wrap(err, "do request")
        }
        defer resp.Body.Close()

        stage = "DecodeResponse"
        result, err := decodeUploadAttachmentResponse(resp)
        if err != nil {
                return res, errors.Wrap(err, "decode response")
        }

        return result, nil
}

// Code generated by ogen, DO NOT EDIT.

package firefly

// setDefaults set default value of fields.
func (s *Account) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(true)
                s.IncludeNetWorth.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *AccountStore) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(true)
                s.IncludeNetWorth.SetTo(val)
        }
        {
                val := string("0")
                s.Interest.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *AccountUpdate) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(true)
                s.IncludeNetWorth.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *Currency) setDefaults() {
        {
                val := bool(true)
                s.Enabled.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *CurrencyStore) setDefaults() {
        {
                val := bool(true)
                s.Enabled.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *Rule) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleAction) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleActionStore) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleStore) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(true)
                s.Strict.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleTrigger) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleTriggerStore) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *RuleUpdate) setDefaults() {
        {
                val := bool(true)
                s.Active.SetTo(val)
        }
        {
                val := bool(false)
                s.StopProcessing.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *TransactionStore) setDefaults() {
        {
                val := bool(true)
                s.FireWebhooks.SetTo(val)
        }
}

// setDefaults set default value of fields.
func (s *TransactionUpdate) setDefaults() {
        {
                val := bool(true)
                s.FireWebhooks.SetTo(val)
        }
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "math/bits"
        "strconv"
        "time"

        "github.com/go-faster/errors"
        "github.com/go-faster/jx"

        "github.com/ogen-go/ogen/json"
        "github.com/ogen-go/ogen/validate"
)

// Encode implements json.Marshaler.
func (s *Account) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Account) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                if s.AccountRole.Set {
                        e.FieldStart("account_role")
                        s.AccountRole.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.CurrentBalance.Set {
                        e.FieldStart("current_balance")
                        s.CurrentBalance.Encode(e)
                }
        }
        {
                if s.CurrentBalanceDate.Set {
                        e.FieldStart("current_balance_date")
                        s.CurrentBalanceDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Iban.Set {
                        e.FieldStart("iban")
                        s.Iban.Encode(e)
                }
        }
        {
                if s.Bic.Set {
                        e.FieldStart("bic")
                        s.Bic.Encode(e)
                }
        }
        {
                if s.AccountNumber.Set {
                        e.FieldStart("account_number")
                        s.AccountNumber.Encode(e)
                }
        }
        {
                if s.OpeningBalance.Set {
                        e.FieldStart("opening_balance")
                        s.OpeningBalance.Encode(e)
                }
        }
        {
                if s.CurrentDebt.Set {
                        e.FieldStart("current_debt")
                        s.CurrentDebt.Encode(e)
                }
        }
        {
                if s.OpeningBalanceDate.Set {
                        e.FieldStart("opening_balance_date")
                        s.OpeningBalanceDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.VirtualBalance.Set {
                        e.FieldStart("virtual_balance")
                        s.VirtualBalance.Encode(e)
                }
        }
        {
                if s.IncludeNetWorth.Set {
                        e.FieldStart("include_net_worth")
                        s.IncludeNetWorth.Encode(e)
                }
        }
        {
                if s.CreditCardType.Set {
                        e.FieldStart("credit_card_type")
                        s.CreditCardType.Encode(e)
                }
        }
        {
                if s.MonthlyPaymentDate.Set {
                        e.FieldStart("monthly_payment_date")
                        s.MonthlyPaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.LiabilityType.Set {
                        e.FieldStart("liability_type")
                        s.LiabilityType.Encode(e)
                }
        }
        {
                if s.LiabilityDirection.Set {
                        e.FieldStart("liability_direction")
                        s.LiabilityDirection.Encode(e)
                }
        }
        {
                if s.Interest.Set {
                        e.FieldStart("interest")
                        s.Interest.Encode(e)
                }
        }
        {
                if s.InterestPeriod.Set {
                        e.FieldStart("interest_period")
                        s.InterestPeriod.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfAccount = [31]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "active",
        3:  "order",
        4:  "name",
        5:  "type",
        6:  "account_role",
        7:  "currency_id",
        8:  "currency_code",
        9:  "currency_symbol",
        10: "currency_decimal_places",
        11: "current_balance",
        12: "current_balance_date",
        13: "iban",
        14: "bic",
        15: "account_number",
        16: "opening_balance",
        17: "current_debt",
        18: "opening_balance_date",
        19: "virtual_balance",
        20: "include_net_worth",
        21: "credit_card_type",
        22: "monthly_payment_date",
        23: "liability_type",
        24: "liability_direction",
        25: "interest",
        26: "interest_period",
        27: "notes",
        28: "latitude",
        29: "longitude",
        30: "zoom_level",
}

// Decode decodes Account from json.
func (s *Account) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Account to nil")
        }
        var requiredBitSet [4]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "account_role":
                        if err := func() error {
                                s.AccountRole.Reset()
                                if err := s.AccountRole.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_role\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "current_balance":
                        if err := func() error {
                                s.CurrentBalance.Reset()
                                if err := s.CurrentBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_balance\"")
                        }
                case "current_balance_date":
                        if err := func() error {
                                s.CurrentBalanceDate.Reset()
                                if err := s.CurrentBalanceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_balance_date\"")
                        }
                case "iban":
                        if err := func() error {
                                s.Iban.Reset()
                                if err := s.Iban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"iban\"")
                        }
                case "bic":
                        if err := func() error {
                                s.Bic.Reset()
                                if err := s.Bic.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bic\"")
                        }
                case "account_number":
                        if err := func() error {
                                s.AccountNumber.Reset()
                                if err := s.AccountNumber.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_number\"")
                        }
                case "opening_balance":
                        if err := func() error {
                                s.OpeningBalance.Reset()
                                if err := s.OpeningBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance\"")
                        }
                case "current_debt":
                        if err := func() error {
                                s.CurrentDebt.Reset()
                                if err := s.CurrentDebt.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_debt\"")
                        }
                case "opening_balance_date":
                        if err := func() error {
                                s.OpeningBalanceDate.Reset()
                                if err := s.OpeningBalanceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance_date\"")
                        }
                case "virtual_balance":
                        if err := func() error {
                                s.VirtualBalance.Reset()
                                if err := s.VirtualBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"virtual_balance\"")
                        }
                case "include_net_worth":
                        if err := func() error {
                                s.IncludeNetWorth.Reset()
                                if err := s.IncludeNetWorth.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"include_net_worth\"")
                        }
                case "credit_card_type":
                        if err := func() error {
                                s.CreditCardType.Reset()
                                if err := s.CreditCardType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"credit_card_type\"")
                        }
                case "monthly_payment_date":
                        if err := func() error {
                                s.MonthlyPaymentDate.Reset()
                                if err := s.MonthlyPaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"monthly_payment_date\"")
                        }
                case "liability_type":
                        if err := func() error {
                                s.LiabilityType.Reset()
                                if err := s.LiabilityType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"liability_type\"")
                        }
                case "liability_direction":
                        if err := func() error {
                                s.LiabilityDirection.Reset()
                                if err := s.LiabilityDirection.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"liability_direction\"")
                        }
                case "interest":
                        if err := func() error {
                                s.Interest.Reset()
                                if err := s.Interest.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest\"")
                        }
                case "interest_period":
                        if err := func() error {
                                s.InterestPeriod.Reset()
                                if err := s.InterestPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_period\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Account")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [4]uint8{
                0b00110000,
                0b00000000,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccount) {
                                        name = jsonFieldsNameOfAccount[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Account) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Account) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AccountArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AccountArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfAccountArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes AccountArray from json.
func (s *AccountArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]AccountRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem AccountRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AccountArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccountArray) {
                                        name = jsonFieldsNameOfAccountArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AccountArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AccountRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AccountRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfAccountRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes AccountRead from json.
func (s *AccountRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AccountRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccountRead) {
                                        name = jsonFieldsNameOfAccountRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AccountRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AccountRoleProperty as json.
func (s AccountRoleProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes AccountRoleProperty from json.
func (s *AccountRoleProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountRoleProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch AccountRoleProperty(v) {
        case AccountRolePropertyDefaultAsset:
                *s = AccountRolePropertyDefaultAsset
        case AccountRolePropertySharedAsset:
                *s = AccountRolePropertySharedAsset
        case AccountRolePropertySavingAsset:
                *s = AccountRolePropertySavingAsset
        case AccountRolePropertyCcAsset:
                *s = AccountRolePropertyCcAsset
        case AccountRolePropertyCashWalletAsset:
                *s = AccountRolePropertyCashWalletAsset
        default:
                *s = AccountRoleProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AccountRoleProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountRoleProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AccountSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AccountSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfAccountSingle = [1]string{
        0: "data",
}

// Decode decodes AccountSingle from json.
func (s *AccountSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AccountSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccountSingle) {
                                        name = jsonFieldsNameOfAccountSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AccountSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AccountStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AccountStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                if s.Iban.Set {
                        e.FieldStart("iban")
                        s.Iban.Encode(e)
                }
        }
        {
                if s.Bic.Set {
                        e.FieldStart("bic")
                        s.Bic.Encode(e)
                }
        }
        {
                if s.AccountNumber.Set {
                        e.FieldStart("account_number")
                        s.AccountNumber.Encode(e)
                }
        }
        {
                if s.OpeningBalance.Set {
                        e.FieldStart("opening_balance")
                        s.OpeningBalance.Encode(e)
                }
        }
        {
                if s.OpeningBalanceDate.Set {
                        e.FieldStart("opening_balance_date")
                        s.OpeningBalanceDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.VirtualBalance.Set {
                        e.FieldStart("virtual_balance")
                        s.VirtualBalance.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.IncludeNetWorth.Set {
                        e.FieldStart("include_net_worth")
                        s.IncludeNetWorth.Encode(e)
                }
        }
        {
                if s.AccountRole.Set {
                        e.FieldStart("account_role")
                        s.AccountRole.Encode(e)
                }
        }
        {
                if s.CreditCardType.Set {
                        e.FieldStart("credit_card_type")
                        s.CreditCardType.Encode(e)
                }
        }
        {
                if s.MonthlyPaymentDate.Set {
                        e.FieldStart("monthly_payment_date")
                        s.MonthlyPaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.LiabilityType.Set {
                        e.FieldStart("liability_type")
                        s.LiabilityType.Encode(e)
                }
        }
        {
                if s.LiabilityDirection.Set {
                        e.FieldStart("liability_direction")
                        s.LiabilityDirection.Encode(e)
                }
        }
        {
                if s.Interest.Set {
                        e.FieldStart("interest")
                        s.Interest.Encode(e)
                }
        }
        {
                if s.InterestPeriod.Set {
                        e.FieldStart("interest_period")
                        s.InterestPeriod.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfAccountStore = [24]string{
        0:  "name",
        1:  "type",
        2:  "iban",
        3:  "bic",
        4:  "account_number",
        5:  "opening_balance",
        6:  "opening_balance_date",
        7:  "virtual_balance",
        8:  "currency_id",
        9:  "currency_code",
        10: "active",
        11: "order",
        12: "include_net_worth",
        13: "account_role",
        14: "credit_card_type",
        15: "monthly_payment_date",
        16: "liability_type",
        17: "liability_direction",
        18: "interest",
        19: "interest_period",
        20: "notes",
        21: "latitude",
        22: "longitude",
        23: "zoom_level",
}

// Decode decodes AccountStore from json.
func (s *AccountStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountStore to nil")
        }
        var requiredBitSet [3]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "iban":
                        if err := func() error {
                                s.Iban.Reset()
                                if err := s.Iban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"iban\"")
                        }
                case "bic":
                        if err := func() error {
                                s.Bic.Reset()
                                if err := s.Bic.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bic\"")
                        }
                case "account_number":
                        if err := func() error {
                                s.AccountNumber.Reset()
                                if err := s.AccountNumber.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_number\"")
                        }
                case "opening_balance":
                        if err := func() error {
                                s.OpeningBalance.Reset()
                                if err := s.OpeningBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance\"")
                        }
                case "opening_balance_date":
                        if err := func() error {
                                s.OpeningBalanceDate.Reset()
                                if err := s.OpeningBalanceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance_date\"")
                        }
                case "virtual_balance":
                        if err := func() error {
                                s.VirtualBalance.Reset()
                                if err := s.VirtualBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"virtual_balance\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "include_net_worth":
                        if err := func() error {
                                s.IncludeNetWorth.Reset()
                                if err := s.IncludeNetWorth.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"include_net_worth\"")
                        }
                case "account_role":
                        if err := func() error {
                                s.AccountRole.Reset()
                                if err := s.AccountRole.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_role\"")
                        }
                case "credit_card_type":
                        if err := func() error {
                                s.CreditCardType.Reset()
                                if err := s.CreditCardType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"credit_card_type\"")
                        }
                case "monthly_payment_date":
                        if err := func() error {
                                s.MonthlyPaymentDate.Reset()
                                if err := s.MonthlyPaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"monthly_payment_date\"")
                        }
                case "liability_type":
                        if err := func() error {
                                s.LiabilityType.Reset()
                                if err := s.LiabilityType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"liability_type\"")
                        }
                case "liability_direction":
                        if err := func() error {
                                s.LiabilityDirection.Reset()
                                if err := s.LiabilityDirection.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"liability_direction\"")
                        }
                case "interest":
                        if err := func() error {
                                s.Interest.Reset()
                                if err := s.Interest.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest\"")
                        }
                case "interest_period":
                        if err := func() error {
                                s.InterestPeriod.Reset()
                                if err := s.InterestPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_period\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AccountStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [3]uint8{
                0b00000011,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccountStore) {
                                        name = jsonFieldsNameOfAccountStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AccountStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AccountTypeProperty as json.
func (s AccountTypeProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes AccountTypeProperty from json.
func (s *AccountTypeProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountTypeProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch AccountTypeProperty(v) {
        case AccountTypePropertyDefaultAccount:
                *s = AccountTypePropertyDefaultAccount
        case AccountTypePropertyCashAccount:
                *s = AccountTypePropertyCashAccount
        case AccountTypePropertyAssetAccount:
                *s = AccountTypePropertyAssetAccount
        case AccountTypePropertyExpenseAccount:
                *s = AccountTypePropertyExpenseAccount
        case AccountTypePropertyRevenueAccount:
                *s = AccountTypePropertyRevenueAccount
        case AccountTypePropertyInitialBalanceAccount:
                *s = AccountTypePropertyInitialBalanceAccount
        case AccountTypePropertyBeneficiaryAccount:
                *s = AccountTypePropertyBeneficiaryAccount
        case AccountTypePropertyImportAccount:
                *s = AccountTypePropertyImportAccount
        case AccountTypePropertyReconciliationAccount:
                *s = AccountTypePropertyReconciliationAccount
        case AccountTypePropertyLoan:
                *s = AccountTypePropertyLoan
        case AccountTypePropertyDebt:
                *s = AccountTypePropertyDebt
        case AccountTypePropertyMortgage:
                *s = AccountTypePropertyMortgage
        default:
                *s = AccountTypeProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AccountTypeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountTypeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AccountUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AccountUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Iban.Set {
                        e.FieldStart("iban")
                        s.Iban.Encode(e)
                }
        }
        {
                if s.Bic.Set {
                        e.FieldStart("bic")
                        s.Bic.Encode(e)
                }
        }
        {
                if s.AccountNumber.Set {
                        e.FieldStart("account_number")
                        s.AccountNumber.Encode(e)
                }
        }
        {
                if s.OpeningBalance.Set {
                        e.FieldStart("opening_balance")
                        s.OpeningBalance.Encode(e)
                }
        }
        {
                if s.OpeningBalanceDate.Set {
                        e.FieldStart("opening_balance_date")
                        s.OpeningBalanceDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.VirtualBalance.Set {
                        e.FieldStart("virtual_balance")
                        s.VirtualBalance.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.IncludeNetWorth.Set {
                        e.FieldStart("include_net_worth")
                        s.IncludeNetWorth.Encode(e)
                }
        }
        {
                if s.AccountRole.Set {
                        e.FieldStart("account_role")
                        s.AccountRole.Encode(e)
                }
        }
        {
                if s.CreditCardType.Set {
                        e.FieldStart("credit_card_type")
                        s.CreditCardType.Encode(e)
                }
        }
        {
                if s.MonthlyPaymentDate.Set {
                        e.FieldStart("monthly_payment_date")
                        s.MonthlyPaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.LiabilityType.Set {
                        e.FieldStart("liability_type")
                        s.LiabilityType.Encode(e)
                }
        }
        {
                if s.Interest.Set {
                        e.FieldStart("interest")
                        s.Interest.Encode(e)
                }
        }
        {
                if s.InterestPeriod.Set {
                        e.FieldStart("interest_period")
                        s.InterestPeriod.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfAccountUpdate = [22]string{
        0:  "name",
        1:  "iban",
        2:  "bic",
        3:  "account_number",
        4:  "opening_balance",
        5:  "opening_balance_date",
        6:  "virtual_balance",
        7:  "currency_id",
        8:  "currency_code",
        9:  "active",
        10: "order",
        11: "include_net_worth",
        12: "account_role",
        13: "credit_card_type",
        14: "monthly_payment_date",
        15: "liability_type",
        16: "interest",
        17: "interest_period",
        18: "notes",
        19: "latitude",
        20: "longitude",
        21: "zoom_level",
}

// Decode decodes AccountUpdate from json.
func (s *AccountUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AccountUpdate to nil")
        }
        var requiredBitSet [3]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "iban":
                        if err := func() error {
                                s.Iban.Reset()
                                if err := s.Iban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"iban\"")
                        }
                case "bic":
                        if err := func() error {
                                s.Bic.Reset()
                                if err := s.Bic.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bic\"")
                        }
                case "account_number":
                        if err := func() error {
                                s.AccountNumber.Reset()
                                if err := s.AccountNumber.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_number\"")
                        }
                case "opening_balance":
                        if err := func() error {
                                s.OpeningBalance.Reset()
                                if err := s.OpeningBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance\"")
                        }
                case "opening_balance_date":
                        if err := func() error {
                                s.OpeningBalanceDate.Reset()
                                if err := s.OpeningBalanceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"opening_balance_date\"")
                        }
                case "virtual_balance":
                        if err := func() error {
                                s.VirtualBalance.Reset()
                                if err := s.VirtualBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"virtual_balance\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "include_net_worth":
                        if err := func() error {
                                s.IncludeNetWorth.Reset()
                                if err := s.IncludeNetWorth.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"include_net_worth\"")
                        }
                case "account_role":
                        if err := func() error {
                                s.AccountRole.Reset()
                                if err := s.AccountRole.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_role\"")
                        }
                case "credit_card_type":
                        if err := func() error {
                                s.CreditCardType.Reset()
                                if err := s.CreditCardType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"credit_card_type\"")
                        }
                case "monthly_payment_date":
                        if err := func() error {
                                s.MonthlyPaymentDate.Reset()
                                if err := s.MonthlyPaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"monthly_payment_date\"")
                        }
                case "liability_type":
                        if err := func() error {
                                s.LiabilityType.Reset()
                                if err := s.LiabilityType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"liability_type\"")
                        }
                case "interest":
                        if err := func() error {
                                s.Interest.Reset()
                                if err := s.Interest.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest\"")
                        }
                case "interest_period":
                        if err := func() error {
                                s.InterestPeriod.Reset()
                                if err := s.InterestPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_period\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AccountUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [3]uint8{
                0b00000001,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAccountUpdate) {
                                        name = jsonFieldsNameOfAccountUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AccountUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AccountUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AttachableType as json.
func (s AttachableType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes AttachableType from json.
func (s *AttachableType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachableType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch AttachableType(v) {
        case AttachableTypeAccount:
                *s = AttachableTypeAccount
        case AttachableTypeBudget:
                *s = AttachableTypeBudget
        case AttachableTypeBill:
                *s = AttachableTypeBill
        case AttachableTypeTransactionJournal:
                *s = AttachableTypeTransactionJournal
        case AttachableTypePiggyBank:
                *s = AttachableTypePiggyBank
        case AttachableTypeTag:
                *s = AttachableTypeTag
        default:
                *s = AttachableType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AttachableType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachableType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Attachment) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Attachment) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("attachable_type")
                s.AttachableType.Encode(e)
        }
        {
                e.FieldStart("attachable_id")
                e.Str(s.AttachableID)
        }
        {
                if s.MD5.Set {
                        e.FieldStart("md5")
                        s.MD5.Encode(e)
                }
        }
        {
                e.FieldStart("filename")
                e.Str(s.Filename)
        }
        {
                if s.DownloadURL.Set {
                        e.FieldStart("download_url")
                        s.DownloadURL.Encode(e)
                }
        }
        {
                if s.UploadURL.Set {
                        e.FieldStart("upload_url")
                        s.UploadURL.Encode(e)
                }
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Mime.Set {
                        e.FieldStart("mime")
                        s.Mime.Encode(e)
                }
        }
        {
                if s.Size.Set {
                        e.FieldStart("size")
                        s.Size.Encode(e)
                }
        }
}

var jsonFieldsNameOfAttachment = [12]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "attachable_type",
        3:  "attachable_id",
        4:  "md5",
        5:  "filename",
        6:  "download_url",
        7:  "upload_url",
        8:  "title",
        9:  "notes",
        10: "mime",
        11: "size",
}

// Decode decodes Attachment from json.
func (s *Attachment) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Attachment to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "attachable_type":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.AttachableType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attachable_type\"")
                        }
                case "attachable_id":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.AttachableID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attachable_id\"")
                        }
                case "md5":
                        if err := func() error {
                                s.MD5.Reset()
                                if err := s.MD5.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"md5\"")
                        }
                case "filename":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := d.Str()
                                s.Filename = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"filename\"")
                        }
                case "download_url":
                        if err := func() error {
                                s.DownloadURL.Reset()
                                if err := s.DownloadURL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"download_url\"")
                        }
                case "upload_url":
                        if err := func() error {
                                s.UploadURL.Reset()
                                if err := s.UploadURL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"upload_url\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "mime":
                        if err := func() error {
                                s.Mime.Reset()
                                if err := s.Mime.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"mime\"")
                        }
                case "size":
                        if err := func() error {
                                s.Size.Reset()
                                if err := s.Size.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"size\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Attachment")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00101100,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAttachment) {
                                        name = jsonFieldsNameOfAttachment[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Attachment) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Attachment) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AttachmentArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AttachmentArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfAttachmentArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes AttachmentArray from json.
func (s *AttachmentArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachmentArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]AttachmentRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem AttachmentRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AttachmentArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAttachmentArray) {
                                        name = jsonFieldsNameOfAttachmentArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AttachmentArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachmentArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AttachmentRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AttachmentRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfAttachmentRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes AttachmentRead from json.
func (s *AttachmentRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachmentRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AttachmentRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAttachmentRead) {
                                        name = jsonFieldsNameOfAttachmentRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AttachmentRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachmentRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AttachmentSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AttachmentSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfAttachmentSingle = [1]string{
        0: "data",
}

// Decode decodes AttachmentSingle from json.
func (s *AttachmentSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachmentSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AttachmentSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAttachmentSingle) {
                                        name = jsonFieldsNameOfAttachmentSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AttachmentSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachmentSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AttachmentStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AttachmentStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("filename")
                e.Str(s.Filename)
        }
        {
                e.FieldStart("attachable_type")
                s.AttachableType.Encode(e)
        }
        {
                e.FieldStart("attachable_id")
                e.Str(s.AttachableID)
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfAttachmentStore = [5]string{
        0: "filename",
        1: "attachable_type",
        2: "attachable_id",
        3: "title",
        4: "notes",
}

// Decode decodes AttachmentStore from json.
func (s *AttachmentStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachmentStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "filename":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Filename = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"filename\"")
                        }
                case "attachable_type":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.AttachableType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attachable_type\"")
                        }
                case "attachable_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.AttachableID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attachable_id\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AttachmentStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAttachmentStore) {
                                        name = jsonFieldsNameOfAttachmentStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AttachmentStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachmentStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AttachmentUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AttachmentUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Filename.Set {
                        e.FieldStart("filename")
                        s.Filename.Encode(e)
                }
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfAttachmentUpdate = [3]string{
        0: "filename",
        1: "title",
        2: "notes",
}

// Decode decodes AttachmentUpdate from json.
func (s *AttachmentUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AttachmentUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "filename":
                        if err := func() error {
                                s.Filename.Reset()
                                if err := s.Filename.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"filename\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AttachmentUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AttachmentUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AttachmentUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutoBudgetPeriod as json.
func (s AutoBudgetPeriod) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes AutoBudgetPeriod from json.
func (s *AutoBudgetPeriod) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutoBudgetPeriod to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch AutoBudgetPeriod(v) {
        case AutoBudgetPeriodDaily:
                *s = AutoBudgetPeriodDaily
        case AutoBudgetPeriodWeekly:
                *s = AutoBudgetPeriodWeekly
        case AutoBudgetPeriodMonthly:
                *s = AutoBudgetPeriodMonthly
        case AutoBudgetPeriodQuarterly:
                *s = AutoBudgetPeriodQuarterly
        case AutoBudgetPeriodHalfYear:
                *s = AutoBudgetPeriodHalfYear
        case AutoBudgetPeriodYearly:
                *s = AutoBudgetPeriodYearly
        default:
                *s = AutoBudgetPeriod(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutoBudgetPeriod) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutoBudgetPeriod) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutoBudgetType as json.
func (s AutoBudgetType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes AutoBudgetType from json.
func (s *AutoBudgetType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutoBudgetType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch AutoBudgetType(v) {
        case AutoBudgetTypeReset:
                *s = AutoBudgetTypeReset
        case AutoBudgetTypeRollover:
                *s = AutoBudgetTypeRollover
        case AutoBudgetTypeNone:
                *s = AutoBudgetTypeNone
        default:
                *s = AutoBudgetType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutoBudgetType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutoBudgetType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteAccount) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteAccount) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("name_with_balance")
                e.Str(s.NameWithBalance)
        }
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("currency_id")
                e.Str(s.CurrencyID)
        }
        {
                e.FieldStart("currency_name")
                e.Str(s.CurrencyName)
        }
        {
                e.FieldStart("currency_code")
                e.Str(s.CurrencyCode)
        }
        {
                e.FieldStart("currency_symbol")
                e.Str(s.CurrencySymbol)
        }
        {
                e.FieldStart("currency_decimal_places")
                e.Int32(s.CurrencyDecimalPlaces)
        }
}

var jsonFieldsNameOfAutocompleteAccount = [9]string{
        0: "id",
        1: "name",
        2: "name_with_balance",
        3: "type",
        4: "currency_id",
        5: "currency_name",
        6: "currency_code",
        7: "currency_symbol",
        8: "currency_decimal_places",
}

// Decode decodes AutocompleteAccount from json.
func (s *AutocompleteAccount) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteAccount to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "name_with_balance":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.NameWithBalance = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name_with_balance\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "currency_id":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.CurrencyID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_name":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := d.Str()
                                s.CurrencyName = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_name\"")
                        }
                case "currency_code":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.CurrencyCode = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        requiredBitSet[0] |= 1 << 7
                        if err := func() error {
                                v, err := d.Str()
                                s.CurrencySymbol = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        requiredBitSet[1] |= 1 << 0
                        if err := func() error {
                                v, err := d.Int32()
                                s.CurrencyDecimalPlaces = int32(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteAccount")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b11111111,
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteAccount) {
                                        name = jsonFieldsNameOfAutocompleteAccount[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteAccount) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteAccount) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteAccountArray as json.
func (s AutocompleteAccountArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteAccount(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteAccountArray from json.
func (s *AutocompleteAccountArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteAccountArray to nil")
        }
        var unwrapped []AutocompleteAccount
        if err := func() error {
                unwrapped = make([]AutocompleteAccount, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteAccount
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteAccountArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteAccountArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteAccountArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteBill) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteBill) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompleteBill = [3]string{
        0: "id",
        1: "name",
        2: "active",
}

// Decode decodes AutocompleteBill from json.
func (s *AutocompleteBill) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteBill to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteBill")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteBill) {
                                        name = jsonFieldsNameOfAutocompleteBill[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteBill) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteBill) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteBillArray as json.
func (s AutocompleteBillArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteBill(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteBillArray from json.
func (s *AutocompleteBillArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteBillArray to nil")
        }
        var unwrapped []AutocompleteBill
        if err := func() error {
                unwrapped = make([]AutocompleteBill, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteBill
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteBillArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteBillArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteBillArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteBudget) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteBudget) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
}

var jsonFieldsNameOfAutocompleteBudget = [2]string{
        0: "id",
        1: "name",
}

// Decode decodes AutocompleteBudget from json.
func (s *AutocompleteBudget) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteBudget to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteBudget")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteBudget) {
                                        name = jsonFieldsNameOfAutocompleteBudget[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteBudget) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteBudget) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteBudgetArray as json.
func (s AutocompleteBudgetArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteBudget(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteBudgetArray from json.
func (s *AutocompleteBudgetArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteBudgetArray to nil")
        }
        var unwrapped []AutocompleteBudget
        if err := func() error {
                unwrapped = make([]AutocompleteBudget, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteBudget
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteBudgetArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteBudgetArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteBudgetArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteCategory) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteCategory) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
}

var jsonFieldsNameOfAutocompleteCategory = [2]string{
        0: "id",
        1: "name",
}

// Decode decodes AutocompleteCategory from json.
func (s *AutocompleteCategory) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCategory to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteCategory")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteCategory) {
                                        name = jsonFieldsNameOfAutocompleteCategory[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteCategory) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCategory) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteCategoryArray as json.
func (s AutocompleteCategoryArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteCategory(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteCategoryArray from json.
func (s *AutocompleteCategoryArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCategoryArray to nil")
        }
        var unwrapped []AutocompleteCategory
        if err := func() error {
                unwrapped = make([]AutocompleteCategory, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteCategory
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteCategoryArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteCategoryArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCategoryArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteCurrency) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteCurrency) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("code")
                e.Str(s.Code)
        }
        {
                e.FieldStart("symbol")
                e.Str(s.Symbol)
        }
        {
                e.FieldStart("decimal_places")
                e.Int32(s.DecimalPlaces)
        }
}

var jsonFieldsNameOfAutocompleteCurrency = [5]string{
        0: "id",
        1: "name",
        2: "code",
        3: "symbol",
        4: "decimal_places",
}

// Decode decodes AutocompleteCurrency from json.
func (s *AutocompleteCurrency) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCurrency to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "code":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Code = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"code\"")
                        }
                case "symbol":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Symbol = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"symbol\"")
                        }
                case "decimal_places":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Int32()
                                s.DecimalPlaces = int32(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteCurrency")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00011111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteCurrency) {
                                        name = jsonFieldsNameOfAutocompleteCurrency[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteCurrency) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCurrency) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteCurrencyArray as json.
func (s AutocompleteCurrencyArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteCurrency(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteCurrencyArray from json.
func (s *AutocompleteCurrencyArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCurrencyArray to nil")
        }
        var unwrapped []AutocompleteCurrency
        if err := func() error {
                unwrapped = make([]AutocompleteCurrency, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteCurrency
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteCurrencyArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteCurrencyArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCurrencyArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteCurrencyCode) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteCurrencyCode) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("code")
                e.Str(s.Code)
        }
        {
                e.FieldStart("symbol")
                e.Str(s.Symbol)
        }
        {
                e.FieldStart("decimal_places")
                e.Int32(s.DecimalPlaces)
        }
}

var jsonFieldsNameOfAutocompleteCurrencyCode = [5]string{
        0: "id",
        1: "name",
        2: "code",
        3: "symbol",
        4: "decimal_places",
}

// Decode decodes AutocompleteCurrencyCode from json.
func (s *AutocompleteCurrencyCode) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCurrencyCode to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "code":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Code = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"code\"")
                        }
                case "symbol":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Symbol = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"symbol\"")
                        }
                case "decimal_places":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Int32()
                                s.DecimalPlaces = int32(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteCurrencyCode")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00011111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteCurrencyCode) {
                                        name = jsonFieldsNameOfAutocompleteCurrencyCode[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteCurrencyCode) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCurrencyCode) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteCurrencyCodeArray as json.
func (s AutocompleteCurrencyCodeArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteCurrencyCode(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteCurrencyCodeArray from json.
func (s *AutocompleteCurrencyCodeArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteCurrencyCodeArray to nil")
        }
        var unwrapped []AutocompleteCurrencyCode
        if err := func() error {
                unwrapped = make([]AutocompleteCurrencyCode, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteCurrencyCode
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteCurrencyCodeArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteCurrencyCodeArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteCurrencyCodeArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteObjectGroup) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteObjectGroup) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
}

var jsonFieldsNameOfAutocompleteObjectGroup = [3]string{
        0: "id",
        1: "title",
        2: "name",
}

// Decode decodes AutocompleteObjectGroup from json.
func (s *AutocompleteObjectGroup) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteObjectGroup to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteObjectGroup")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteObjectGroup) {
                                        name = jsonFieldsNameOfAutocompleteObjectGroup[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteObjectGroup) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteObjectGroup) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteObjectGroupArray as json.
func (s AutocompleteObjectGroupArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteObjectGroup(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteObjectGroupArray from json.
func (s *AutocompleteObjectGroupArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteObjectGroupArray to nil")
        }
        var unwrapped []AutocompleteObjectGroup
        if err := func() error {
                unwrapped = make([]AutocompleteObjectGroup, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteObjectGroup
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteObjectGroupArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteObjectGroupArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteObjectGroupArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompletePiggy) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompletePiggy) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyName.Set {
                        e.FieldStart("currency_name")
                        s.CurrencyName.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompletePiggy = [9]string{
        0: "id",
        1: "name",
        2: "currency_id",
        3: "currency_code",
        4: "currency_symbol",
        5: "currency_name",
        6: "currency_decimal_places",
        7: "object_group_id",
        8: "object_group_title",
}

// Decode decodes AutocompletePiggy from json.
func (s *AutocompletePiggy) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompletePiggy to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_name":
                        if err := func() error {
                                s.CurrencyName.Reset()
                                if err := s.CurrencyName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_name\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompletePiggy")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000011,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompletePiggy) {
                                        name = jsonFieldsNameOfAutocompletePiggy[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompletePiggy) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompletePiggy) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompletePiggyArray as json.
func (s AutocompletePiggyArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompletePiggy(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompletePiggyArray from json.
func (s *AutocompletePiggyArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompletePiggyArray to nil")
        }
        var unwrapped []AutocompletePiggy
        if err := func() error {
                unwrapped = make([]AutocompletePiggy, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompletePiggy
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompletePiggyArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompletePiggyArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompletePiggyArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompletePiggyBalance) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompletePiggyBalance) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.NameWithBalance.Set {
                        e.FieldStart("name_with_balance")
                        s.NameWithBalance.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompletePiggyBalance = [9]string{
        0: "id",
        1: "name",
        2: "name_with_balance",
        3: "currency_id",
        4: "currency_code",
        5: "currency_symbol",
        6: "currency_decimal_places",
        7: "object_group_id",
        8: "object_group_title",
}

// Decode decodes AutocompletePiggyBalance from json.
func (s *AutocompletePiggyBalance) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompletePiggyBalance to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "name_with_balance":
                        if err := func() error {
                                s.NameWithBalance.Reset()
                                if err := s.NameWithBalance.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name_with_balance\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompletePiggyBalance")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000011,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompletePiggyBalance) {
                                        name = jsonFieldsNameOfAutocompletePiggyBalance[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompletePiggyBalance) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompletePiggyBalance) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompletePiggyBalanceArray as json.
func (s AutocompletePiggyBalanceArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompletePiggyBalance(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompletePiggyBalanceArray from json.
func (s *AutocompletePiggyBalanceArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompletePiggyBalanceArray to nil")
        }
        var unwrapped []AutocompletePiggyBalance
        if err := func() error {
                unwrapped = make([]AutocompletePiggyBalance, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompletePiggyBalance
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompletePiggyBalanceArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompletePiggyBalanceArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompletePiggyBalanceArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteRecurrence) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteRecurrence) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompleteRecurrence = [3]string{
        0: "id",
        1: "name",
        2: "description",
}

// Decode decodes AutocompleteRecurrence from json.
func (s *AutocompleteRecurrence) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRecurrence to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteRecurrence")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteRecurrence) {
                                        name = jsonFieldsNameOfAutocompleteRecurrence[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteRecurrence) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRecurrence) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteRecurrenceArray as json.
func (s AutocompleteRecurrenceArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteRecurrence(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteRecurrenceArray from json.
func (s *AutocompleteRecurrenceArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRecurrenceArray to nil")
        }
        var unwrapped []AutocompleteRecurrence
        if err := func() error {
                unwrapped = make([]AutocompleteRecurrence, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteRecurrence
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteRecurrenceArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteRecurrenceArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRecurrenceArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteRule) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteRule) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompleteRule = [3]string{
        0: "id",
        1: "name",
        2: "description",
}

// Decode decodes AutocompleteRule from json.
func (s *AutocompleteRule) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRule to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteRule")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteRule) {
                                        name = jsonFieldsNameOfAutocompleteRule[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteRule) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRule) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteRuleArray as json.
func (s AutocompleteRuleArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteRule(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteRuleArray from json.
func (s *AutocompleteRuleArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRuleArray to nil")
        }
        var unwrapped []AutocompleteRule
        if err := func() error {
                unwrapped = make([]AutocompleteRule, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteRule
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteRuleArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteRuleArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRuleArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteRuleGroup) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteRuleGroup) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
}

var jsonFieldsNameOfAutocompleteRuleGroup = [3]string{
        0: "id",
        1: "name",
        2: "description",
}

// Decode decodes AutocompleteRuleGroup from json.
func (s *AutocompleteRuleGroup) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRuleGroup to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteRuleGroup")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteRuleGroup) {
                                        name = jsonFieldsNameOfAutocompleteRuleGroup[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteRuleGroup) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRuleGroup) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteRuleGroupArray as json.
func (s AutocompleteRuleGroupArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteRuleGroup(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteRuleGroupArray from json.
func (s *AutocompleteRuleGroupArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteRuleGroupArray to nil")
        }
        var unwrapped []AutocompleteRuleGroup
        if err := func() error {
                unwrapped = make([]AutocompleteRuleGroup, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteRuleGroup
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteRuleGroupArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteRuleGroupArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteRuleGroupArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteTag) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteTag) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("tag")
                e.Str(s.Tag)
        }
}

var jsonFieldsNameOfAutocompleteTag = [3]string{
        0: "id",
        1: "name",
        2: "tag",
}

// Decode decodes AutocompleteTag from json.
func (s *AutocompleteTag) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTag to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "tag":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Tag = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tag\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteTag")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteTag) {
                                        name = jsonFieldsNameOfAutocompleteTag[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteTag) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTag) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteTagArray as json.
func (s AutocompleteTagArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteTag(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteTagArray from json.
func (s *AutocompleteTagArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTagArray to nil")
        }
        var unwrapped []AutocompleteTag
        if err := func() error {
                unwrapped = make([]AutocompleteTag, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteTag
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteTagArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteTagArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTagArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteTransaction) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteTransaction) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                if s.TransactionGroupID.Set {
                        e.FieldStart("transaction_group_id")
                        s.TransactionGroupID.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
}

var jsonFieldsNameOfAutocompleteTransaction = [4]string{
        0: "id",
        1: "transaction_group_id",
        2: "name",
        3: "description",
}

// Decode decodes AutocompleteTransaction from json.
func (s *AutocompleteTransaction) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransaction to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "transaction_group_id":
                        if err := func() error {
                                s.TransactionGroupID.Reset()
                                if err := s.TransactionGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_group_id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "description":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteTransaction")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001101,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteTransaction) {
                                        name = jsonFieldsNameOfAutocompleteTransaction[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteTransaction) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransaction) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteTransactionArray as json.
func (s AutocompleteTransactionArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteTransaction(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteTransactionArray from json.
func (s *AutocompleteTransactionArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransactionArray to nil")
        }
        var unwrapped []AutocompleteTransaction
        if err := func() error {
                unwrapped = make([]AutocompleteTransaction, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteTransaction
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteTransactionArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteTransactionArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransactionArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteTransactionID) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteTransactionID) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                if s.TransactionGroupID.Set {
                        e.FieldStart("transaction_group_id")
                        s.TransactionGroupID.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
}

var jsonFieldsNameOfAutocompleteTransactionID = [4]string{
        0: "id",
        1: "transaction_group_id",
        2: "name",
        3: "description",
}

// Decode decodes AutocompleteTransactionID from json.
func (s *AutocompleteTransactionID) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransactionID to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "transaction_group_id":
                        if err := func() error {
                                s.TransactionGroupID.Reset()
                                if err := s.TransactionGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_group_id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "description":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteTransactionID")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001101,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteTransactionID) {
                                        name = jsonFieldsNameOfAutocompleteTransactionID[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteTransactionID) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransactionID) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteTransactionIDArray as json.
func (s AutocompleteTransactionIDArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteTransactionID(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteTransactionIDArray from json.
func (s *AutocompleteTransactionIDArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransactionIDArray to nil")
        }
        var unwrapped []AutocompleteTransactionID
        if err := func() error {
                unwrapped = make([]AutocompleteTransactionID, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteTransactionID
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteTransactionIDArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteTransactionIDArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransactionIDArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AutocompleteTransactionType) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AutocompleteTransactionType) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
}

var jsonFieldsNameOfAutocompleteTransactionType = [3]string{
        0: "id",
        1: "name",
        2: "type",
}

// Decode decodes AutocompleteTransactionType from json.
func (s *AutocompleteTransactionType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransactionType to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AutocompleteTransactionType")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAutocompleteTransactionType) {
                                        name = jsonFieldsNameOfAutocompleteTransactionType[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AutocompleteTransactionType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransactionType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutocompleteTransactionTypeArray as json.
func (s AutocompleteTransactionTypeArray) Encode(e *jx.Encoder) {
        unwrapped := []AutocompleteTransactionType(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes AutocompleteTransactionTypeArray from json.
func (s *AutocompleteTransactionTypeArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AutocompleteTransactionTypeArray to nil")
        }
        var unwrapped []AutocompleteTransactionType
        if err := func() error {
                unwrapped = make([]AutocompleteTransactionType, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem AutocompleteTransactionType
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = AutocompleteTransactionTypeArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s AutocompleteTransactionTypeArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AutocompleteTransactionTypeArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AvailableBudget) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AvailableBudget) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                e.FieldStart("start")
                json.EncodeDateTime(e, s.Start)
        }
        {
                e.FieldStart("end")
                json.EncodeDateTime(e, s.End)
        }
        {
                if s.SpentInBudgets != nil {
                        e.FieldStart("spent_in_budgets")
                        e.ArrStart()
                        for _, elem := range s.SpentInBudgets {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.SpentOutsideBudget != nil {
                        e.FieldStart("spent_outside_budget")
                        e.ArrStart()
                        for _, elem := range s.SpentOutsideBudget {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfAvailableBudget = [11]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "currency_id",
        3:  "currency_code",
        4:  "currency_symbol",
        5:  "currency_decimal_places",
        6:  "amount",
        7:  "start",
        8:  "end",
        9:  "spent_in_budgets",
        10: "spent_outside_budget",
}

// Decode decodes AvailableBudget from json.
func (s *AvailableBudget) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AvailableBudget to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "amount":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "start":
                        requiredBitSet[0] |= 1 << 7
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Start = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start\"")
                        }
                case "end":
                        requiredBitSet[1] |= 1 << 0
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.End = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end\"")
                        }
                case "spent_in_budgets":
                        if err := func() error {
                                s.SpentInBudgets = make([]BudgetSpent, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BudgetSpent
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.SpentInBudgets = append(s.SpentInBudgets, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"spent_in_budgets\"")
                        }
                case "spent_outside_budget":
                        if err := func() error {
                                s.SpentOutsideBudget = make([]BudgetSpent, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BudgetSpent
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.SpentOutsideBudget = append(s.SpentOutsideBudget, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"spent_outside_budget\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AvailableBudget")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b11000000,
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAvailableBudget) {
                                        name = jsonFieldsNameOfAvailableBudget[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AvailableBudget) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AvailableBudget) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AvailableBudgetArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AvailableBudgetArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfAvailableBudgetArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes AvailableBudgetArray from json.
func (s *AvailableBudgetArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AvailableBudgetArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]AvailableBudgetRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem AvailableBudgetRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AvailableBudgetArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAvailableBudgetArray) {
                                        name = jsonFieldsNameOfAvailableBudgetArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AvailableBudgetArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AvailableBudgetArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AvailableBudgetRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AvailableBudgetRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfAvailableBudgetRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes AvailableBudgetRead from json.
func (s *AvailableBudgetRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AvailableBudgetRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AvailableBudgetRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAvailableBudgetRead) {
                                        name = jsonFieldsNameOfAvailableBudgetRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AvailableBudgetRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AvailableBudgetRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *AvailableBudgetSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *AvailableBudgetSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfAvailableBudgetSingle = [1]string{
        0: "data",
}

// Decode decodes AvailableBudgetSingle from json.
func (s *AvailableBudgetSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode AvailableBudgetSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode AvailableBudgetSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfAvailableBudgetSingle) {
                                        name = jsonFieldsNameOfAvailableBudgetSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *AvailableBudgetSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AvailableBudgetSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BadRequest) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BadRequest) encodeFields(e *jx.Encoder) {
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
        {
                if s.Exception.Set {
                        e.FieldStart("exception")
                        s.Exception.Encode(e)
                }
        }
}

var jsonFieldsNameOfBadRequest = [2]string{
        0: "message",
        1: "exception",
}

// Decode decodes BadRequest from json.
func (s *BadRequest) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BadRequest to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                case "exception":
                        if err := func() error {
                                s.Exception.Reset()
                                if err := s.Exception.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"exception\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BadRequest")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BadRequest) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BadRequest) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s BasicSummary) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields implements json.Marshaler.
func (s BasicSummary) encodeFields(e *jx.Encoder) {
        for k, elem := range s {
                e.FieldStart(k)

                elem.Encode(e)
        }
}

// Decode decodes BasicSummary from json.
func (s *BasicSummary) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BasicSummary to nil")
        }
        m := s.init()
        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                var elem BasicSummaryEntry
                if err := func() error {
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        return errors.Wrapf(err, "decode field %q", k)
                }
                m[string(k)] = elem
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BasicSummary")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s BasicSummary) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BasicSummary) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BasicSummaryEntry) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BasicSummaryEntry) encodeFields(e *jx.Encoder) {
        {
                if s.Key.Set {
                        e.FieldStart("key")
                        s.Key.Encode(e)
                }
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.MonetaryValue.Set {
                        e.FieldStart("monetary_value")
                        s.MonetaryValue.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ValueParsed.Set {
                        e.FieldStart("value_parsed")
                        s.ValueParsed.Encode(e)
                }
        }
        {
                if s.LocalIcon.Set {
                        e.FieldStart("local_icon")
                        s.LocalIcon.Encode(e)
                }
        }
        {
                if s.SubTitle.Set {
                        e.FieldStart("sub_title")
                        s.SubTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfBasicSummaryEntry = [10]string{
        0: "key",
        1: "title",
        2: "monetary_value",
        3: "currency_id",
        4: "currency_code",
        5: "currency_symbol",
        6: "currency_decimal_places",
        7: "value_parsed",
        8: "local_icon",
        9: "sub_title",
}

// Decode decodes BasicSummaryEntry from json.
func (s *BasicSummaryEntry) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BasicSummaryEntry to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "key":
                        if err := func() error {
                                s.Key.Reset()
                                if err := s.Key.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"key\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "monetary_value":
                        if err := func() error {
                                s.MonetaryValue.Reset()
                                if err := s.MonetaryValue.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"monetary_value\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "value_parsed":
                        if err := func() error {
                                s.ValueParsed.Reset()
                                if err := s.ValueParsed.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value_parsed\"")
                        }
                case "local_icon":
                        if err := func() error {
                                s.LocalIcon.Reset()
                                if err := s.LocalIcon.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"local_icon\"")
                        }
                case "sub_title":
                        if err := func() error {
                                s.SubTitle.Reset()
                                if err := s.SubTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sub_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BasicSummaryEntry")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BasicSummaryEntry) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BasicSummaryEntry) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Bill) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Bill) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("amount_min")
                e.Str(s.AmountMin)
        }
        {
                e.FieldStart("amount_max")
                e.Str(s.AmountMax)
        }
        {
                e.FieldStart("date")
                json.EncodeDateTime(e, s.Date)
        }
        {
                if s.EndDate.Set {
                        e.FieldStart("end_date")
                        s.EndDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ExtensionDate.Set {
                        e.FieldStart("extension_date")
                        s.ExtensionDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("repeat_freq")
                s.RepeatFreq.Encode(e)
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.NextExpectedMatch.Set {
                        e.FieldStart("next_expected_match")
                        s.NextExpectedMatch.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.NextExpectedMatchDiff.Set {
                        e.FieldStart("next_expected_match_diff")
                        s.NextExpectedMatchDiff.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupOrder.Set {
                        e.FieldStart("object_group_order")
                        s.ObjectGroupOrder.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
        {
                if s.PayDates != nil {
                        e.FieldStart("pay_dates")
                        e.ArrStart()
                        for _, elem := range s.PayDates {
                                json.EncodeDateTime(e, elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.PaidDates != nil {
                        e.FieldStart("paid_dates")
                        e.ArrStart()
                        for _, elem := range s.PaidDates {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfBill = [24]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "currency_id",
        3:  "currency_code",
        4:  "currency_symbol",
        5:  "currency_decimal_places",
        6:  "name",
        7:  "amount_min",
        8:  "amount_max",
        9:  "date",
        10: "end_date",
        11: "extension_date",
        12: "repeat_freq",
        13: "skip",
        14: "active",
        15: "order",
        16: "notes",
        17: "next_expected_match",
        18: "next_expected_match_diff",
        19: "object_group_id",
        20: "object_group_order",
        21: "object_group_title",
        22: "pay_dates",
        23: "paid_dates",
}

// Decode decodes Bill from json.
func (s *Bill) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Bill to nil")
        }
        var requiredBitSet [3]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "amount_min":
                        requiredBitSet[0] |= 1 << 7
                        if err := func() error {
                                v, err := d.Str()
                                s.AmountMin = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_min\"")
                        }
                case "amount_max":
                        requiredBitSet[1] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.AmountMax = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_max\"")
                        }
                case "date":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Date = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "end_date":
                        if err := func() error {
                                s.EndDate.Reset()
                                if err := s.EndDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end_date\"")
                        }
                case "extension_date":
                        if err := func() error {
                                s.ExtensionDate.Reset()
                                if err := s.ExtensionDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"extension_date\"")
                        }
                case "repeat_freq":
                        requiredBitSet[1] |= 1 << 4
                        if err := func() error {
                                if err := s.RepeatFreq.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_freq\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "next_expected_match":
                        if err := func() error {
                                s.NextExpectedMatch.Reset()
                                if err := s.NextExpectedMatch.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"next_expected_match\"")
                        }
                case "next_expected_match_diff":
                        if err := func() error {
                                s.NextExpectedMatchDiff.Reset()
                                if err := s.NextExpectedMatchDiff.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"next_expected_match_diff\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_order":
                        if err := func() error {
                                s.ObjectGroupOrder.Reset()
                                if err := s.ObjectGroupOrder.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_order\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                case "pay_dates":
                        if err := func() error {
                                s.PayDates = make([]time.Time, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem time.Time
                                        v, err := json.DecodeDateTime(d)
                                        elem = v
                                        if err != nil {
                                                return err
                                        }
                                        s.PayDates = append(s.PayDates, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"pay_dates\"")
                        }
                case "paid_dates":
                        if err := func() error {
                                s.PaidDates = make([]BillPaidDatesItem, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BillPaidDatesItem
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.PaidDates = append(s.PaidDates, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"paid_dates\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Bill")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [3]uint8{
                0b11000000,
                0b00010011,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBill) {
                                        name = jsonFieldsNameOfBill[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Bill) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Bill) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfBillArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes BillArray from json.
func (s *BillArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]BillRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BillRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBillArray) {
                                        name = jsonFieldsNameOfBillArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillPaidDatesItem) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillPaidDatesItem) encodeFields(e *jx.Encoder) {
        {
                if s.TransactionGroupID.Set {
                        e.FieldStart("transaction_group_id")
                        s.TransactionGroupID.Encode(e)
                }
        }
        {
                if s.TransactionJournalID.Set {
                        e.FieldStart("transaction_journal_id")
                        s.TransactionJournalID.Encode(e)
                }
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDateTime)
                }
        }
}

var jsonFieldsNameOfBillPaidDatesItem = [3]string{
        0: "transaction_group_id",
        1: "transaction_journal_id",
        2: "date",
}

// Decode decodes BillPaidDatesItem from json.
func (s *BillPaidDatesItem) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillPaidDatesItem to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "transaction_group_id":
                        if err := func() error {
                                s.TransactionGroupID.Reset()
                                if err := s.TransactionGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_group_id\"")
                        }
                case "transaction_journal_id":
                        if err := func() error {
                                s.TransactionJournalID.Reset()
                                if err := s.TransactionJournalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_journal_id\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillPaidDatesItem")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillPaidDatesItem) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillPaidDatesItem) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfBillRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes BillRead from json.
func (s *BillRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBillRead) {
                                        name = jsonFieldsNameOfBillRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes BillRepeatFrequency as json.
func (s BillRepeatFrequency) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes BillRepeatFrequency from json.
func (s *BillRepeatFrequency) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillRepeatFrequency to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch BillRepeatFrequency(v) {
        case BillRepeatFrequencyWeekly:
                *s = BillRepeatFrequencyWeekly
        case BillRepeatFrequencyMonthly:
                *s = BillRepeatFrequencyMonthly
        case BillRepeatFrequencyQuarterly:
                *s = BillRepeatFrequencyQuarterly
        case BillRepeatFrequencyHalfYear:
                *s = BillRepeatFrequencyHalfYear
        case BillRepeatFrequencyYearly:
                *s = BillRepeatFrequencyYearly
        default:
                *s = BillRepeatFrequency(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s BillRepeatFrequency) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillRepeatFrequency) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfBillSingle = [1]string{
        0: "data",
}

// Decode decodes BillSingle from json.
func (s *BillSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBillSingle) {
                                        name = jsonFieldsNameOfBillSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillStore) encodeFields(e *jx.Encoder) {
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("amount_min")
                e.Str(s.AmountMin)
        }
        {
                e.FieldStart("amount_max")
                e.Str(s.AmountMax)
        }
        {
                e.FieldStart("date")
                json.EncodeDateTime(e, s.Date)
        }
        {
                if s.EndDate.Set {
                        e.FieldStart("end_date")
                        s.EndDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ExtensionDate.Set {
                        e.FieldStart("extension_date")
                        s.ExtensionDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("repeat_freq")
                s.RepeatFreq.Encode(e)
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfBillStore = [14]string{
        0:  "currency_id",
        1:  "currency_code",
        2:  "name",
        3:  "amount_min",
        4:  "amount_max",
        5:  "date",
        6:  "end_date",
        7:  "extension_date",
        8:  "repeat_freq",
        9:  "skip",
        10: "active",
        11: "notes",
        12: "object_group_id",
        13: "object_group_title",
}

// Decode decodes BillStore from json.
func (s *BillStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillStore to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "amount_min":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.AmountMin = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_min\"")
                        }
                case "amount_max":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.AmountMax = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_max\"")
                        }
                case "date":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Date = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "end_date":
                        if err := func() error {
                                s.EndDate.Reset()
                                if err := s.EndDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end_date\"")
                        }
                case "extension_date":
                        if err := func() error {
                                s.ExtensionDate.Reset()
                                if err := s.ExtensionDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"extension_date\"")
                        }
                case "repeat_freq":
                        requiredBitSet[1] |= 1 << 0
                        if err := func() error {
                                if err := s.RepeatFreq.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_freq\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00111100,
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBillStore) {
                                        name = jsonFieldsNameOfBillStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BillUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BillUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.AmountMin.Set {
                        e.FieldStart("amount_min")
                        s.AmountMin.Encode(e)
                }
        }
        {
                if s.AmountMax.Set {
                        e.FieldStart("amount_max")
                        s.AmountMax.Encode(e)
                }
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.EndDate.Set {
                        e.FieldStart("end_date")
                        s.EndDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ExtensionDate.Set {
                        e.FieldStart("extension_date")
                        s.ExtensionDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.RepeatFreq.Set {
                        e.FieldStart("repeat_freq")
                        s.RepeatFreq.Encode(e)
                }
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfBillUpdate = [14]string{
        0:  "currency_id",
        1:  "currency_code",
        2:  "name",
        3:  "amount_min",
        4:  "amount_max",
        5:  "date",
        6:  "end_date",
        7:  "extension_date",
        8:  "repeat_freq",
        9:  "skip",
        10: "active",
        11: "notes",
        12: "object_group_id",
        13: "object_group_title",
}

// Decode decodes BillUpdate from json.
func (s *BillUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BillUpdate to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "amount_min":
                        if err := func() error {
                                s.AmountMin.Reset()
                                if err := s.AmountMin.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_min\"")
                        }
                case "amount_max":
                        if err := func() error {
                                s.AmountMax.Reset()
                                if err := s.AmountMax.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount_max\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "end_date":
                        if err := func() error {
                                s.EndDate.Reset()
                                if err := s.EndDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end_date\"")
                        }
                case "extension_date":
                        if err := func() error {
                                s.ExtensionDate.Reset()
                                if err := s.ExtensionDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"extension_date\"")
                        }
                case "repeat_freq":
                        if err := func() error {
                                s.RepeatFreq.Reset()
                                if err := s.RepeatFreq.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_freq\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BillUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000100,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBillUpdate) {
                                        name = jsonFieldsNameOfBillUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BillUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BillUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Budget) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Budget) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.AutoBudgetType.Set {
                        e.FieldStart("auto_budget_type")
                        s.AutoBudgetType.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyID.Set {
                        e.FieldStart("auto_budget_currency_id")
                        s.AutoBudgetCurrencyID.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyCode.Set {
                        e.FieldStart("auto_budget_currency_code")
                        s.AutoBudgetCurrencyCode.Encode(e)
                }
        }
        {
                if s.AutoBudgetAmount.Set {
                        e.FieldStart("auto_budget_amount")
                        s.AutoBudgetAmount.Encode(e)
                }
        }
        {
                if s.AutoBudgetPeriod.Set {
                        e.FieldStart("auto_budget_period")
                        s.AutoBudgetPeriod.Encode(e)
                }
        }
        {
                if s.Spent != nil {
                        e.FieldStart("spent")
                        e.ArrStart()
                        for _, elem := range s.Spent {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfBudget = [12]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "name",
        3:  "active",
        4:  "notes",
        5:  "order",
        6:  "auto_budget_type",
        7:  "auto_budget_currency_id",
        8:  "auto_budget_currency_code",
        9:  "auto_budget_amount",
        10: "auto_budget_period",
        11: "spent",
}

// Decode decodes Budget from json.
func (s *Budget) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Budget to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "auto_budget_type":
                        if err := func() error {
                                s.AutoBudgetType.Reset()
                                if err := s.AutoBudgetType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_type\"")
                        }
                case "auto_budget_currency_id":
                        if err := func() error {
                                s.AutoBudgetCurrencyID.Reset()
                                if err := s.AutoBudgetCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_id\"")
                        }
                case "auto_budget_currency_code":
                        if err := func() error {
                                s.AutoBudgetCurrencyCode.Reset()
                                if err := s.AutoBudgetCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_code\"")
                        }
                case "auto_budget_amount":
                        if err := func() error {
                                s.AutoBudgetAmount.Reset()
                                if err := s.AutoBudgetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_amount\"")
                        }
                case "auto_budget_period":
                        if err := func() error {
                                s.AutoBudgetPeriod.Reset()
                                if err := s.AutoBudgetPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_period\"")
                        }
                case "spent":
                        if err := func() error {
                                s.Spent = make([]BudgetSpent, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BudgetSpent
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Spent = append(s.Spent, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"spent\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Budget")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000100,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudget) {
                                        name = jsonFieldsNameOfBudget[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Budget) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Budget) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfBudgetArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes BudgetArray from json.
func (s *BudgetArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]BudgetRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BudgetRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetArray) {
                                        name = jsonFieldsNameOfBudgetArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetLimit) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetLimit) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("start")
                json.EncodeDateTime(e, s.Start)
        }
        {
                e.FieldStart("end")
                json.EncodeDateTime(e, s.End)
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencyName.Set {
                        e.FieldStart("currency_name")
                        s.CurrencyName.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                e.FieldStart("budget_id")
                e.Str(s.BudgetID)
        }
        {
                if s.Period.Set {
                        e.FieldStart("period")
                        s.Period.Encode(e)
                }
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                if s.Spent.Set {
                        e.FieldStart("spent")
                        s.Spent.Encode(e)
                }
        }
}

var jsonFieldsNameOfBudgetLimit = [13]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "start",
        3:  "end",
        4:  "currency_id",
        5:  "currency_code",
        6:  "currency_name",
        7:  "currency_symbol",
        8:  "currency_decimal_places",
        9:  "budget_id",
        10: "period",
        11: "amount",
        12: "spent",
}

// Decode decodes BudgetLimit from json.
func (s *BudgetLimit) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetLimit to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "start":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Start = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start\"")
                        }
                case "end":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.End = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_name":
                        if err := func() error {
                                s.CurrencyName.Reset()
                                if err := s.CurrencyName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_name\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "budget_id":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.BudgetID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "period":
                        if err := func() error {
                                s.Period.Reset()
                                if err := s.Period.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"period\"")
                        }
                case "amount":
                        requiredBitSet[1] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "spent":
                        if err := func() error {
                                s.Spent.Reset()
                                if err := s.Spent.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"spent\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetLimit")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00001100,
                0b00001010,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetLimit) {
                                        name = jsonFieldsNameOfBudgetLimit[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetLimit) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetLimit) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetLimitArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetLimitArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfBudgetLimitArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes BudgetLimitArray from json.
func (s *BudgetLimitArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetLimitArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]BudgetLimitRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem BudgetLimitRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetLimitArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetLimitArray) {
                                        name = jsonFieldsNameOfBudgetLimitArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetLimitArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetLimitArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetLimitRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetLimitRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfBudgetLimitRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes BudgetLimitRead from json.
func (s *BudgetLimitRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetLimitRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetLimitRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetLimitRead) {
                                        name = jsonFieldsNameOfBudgetLimitRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetLimitRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetLimitRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetLimitSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetLimitSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfBudgetLimitSingle = [1]string{
        0: "data",
}

// Decode decodes BudgetLimitSingle from json.
func (s *BudgetLimitSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetLimitSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetLimitSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetLimitSingle) {
                                        name = jsonFieldsNameOfBudgetLimitSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetLimitSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetLimitSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetLimitStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetLimitStore) encodeFields(e *jx.Encoder) {
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                e.FieldStart("budget_id")
                e.Str(s.BudgetID)
        }
        {
                e.FieldStart("start")
                json.EncodeDate(e, s.Start)
        }
        {
                if s.Period.Set {
                        e.FieldStart("period")
                        s.Period.Encode(e)
                }
        }
        {
                e.FieldStart("end")
                json.EncodeDate(e, s.End)
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
}

var jsonFieldsNameOfBudgetLimitStore = [7]string{
        0: "currency_id",
        1: "currency_code",
        2: "budget_id",
        3: "start",
        4: "period",
        5: "end",
        6: "amount",
}

// Decode decodes BudgetLimitStore from json.
func (s *BudgetLimitStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetLimitStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "budget_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.BudgetID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "start":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := json.DecodeDate(d)
                                s.Start = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start\"")
                        }
                case "period":
                        if err := func() error {
                                s.Period.Reset()
                                if err := s.Period.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"period\"")
                        }
                case "end":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := json.DecodeDate(d)
                                s.End = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end\"")
                        }
                case "amount":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetLimitStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b01101100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetLimitStore) {
                                        name = jsonFieldsNameOfBudgetLimitStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetLimitStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetLimitStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfBudgetRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes BudgetRead from json.
func (s *BudgetRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetRead) {
                                        name = jsonFieldsNameOfBudgetRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfBudgetSingle = [1]string{
        0: "data",
}

// Decode decodes BudgetSingle from json.
func (s *BudgetSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetSingle) {
                                        name = jsonFieldsNameOfBudgetSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetSpent) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetSpent) encodeFields(e *jx.Encoder) {
        {
                if s.Sum.Set {
                        e.FieldStart("sum")
                        s.Sum.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
}

var jsonFieldsNameOfBudgetSpent = [5]string{
        0: "sum",
        1: "currency_id",
        2: "currency_code",
        3: "currency_symbol",
        4: "currency_decimal_places",
}

// Decode decodes BudgetSpent from json.
func (s *BudgetSpent) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetSpent to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "sum":
                        if err := func() error {
                                s.Sum.Reset()
                                if err := s.Sum.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sum\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetSpent")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetSpent) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetSpent) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.AutoBudgetType.Set {
                        e.FieldStart("auto_budget_type")
                        s.AutoBudgetType.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyID.Set {
                        e.FieldStart("auto_budget_currency_id")
                        s.AutoBudgetCurrencyID.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyCode.Set {
                        e.FieldStart("auto_budget_currency_code")
                        s.AutoBudgetCurrencyCode.Encode(e)
                }
        }
        {
                if s.AutoBudgetAmount.Set {
                        e.FieldStart("auto_budget_amount")
                        s.AutoBudgetAmount.Encode(e)
                }
        }
        {
                if s.AutoBudgetPeriod.Set {
                        e.FieldStart("auto_budget_period")
                        s.AutoBudgetPeriod.Encode(e)
                }
        }
}

var jsonFieldsNameOfBudgetStore = [9]string{
        0: "name",
        1: "active",
        2: "order",
        3: "notes",
        4: "auto_budget_type",
        5: "auto_budget_currency_id",
        6: "auto_budget_currency_code",
        7: "auto_budget_amount",
        8: "auto_budget_period",
}

// Decode decodes BudgetStore from json.
func (s *BudgetStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetStore to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "auto_budget_type":
                        if err := func() error {
                                s.AutoBudgetType.Reset()
                                if err := s.AutoBudgetType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_type\"")
                        }
                case "auto_budget_currency_id":
                        if err := func() error {
                                s.AutoBudgetCurrencyID.Reset()
                                if err := s.AutoBudgetCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_id\"")
                        }
                case "auto_budget_currency_code":
                        if err := func() error {
                                s.AutoBudgetCurrencyCode.Reset()
                                if err := s.AutoBudgetCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_code\"")
                        }
                case "auto_budget_amount":
                        if err := func() error {
                                s.AutoBudgetAmount.Reset()
                                if err := s.AutoBudgetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_amount\"")
                        }
                case "auto_budget_period":
                        if err := func() error {
                                s.AutoBudgetPeriod.Reset()
                                if err := s.AutoBudgetPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_period\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000001,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetStore) {
                                        name = jsonFieldsNameOfBudgetStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *BudgetUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *BudgetUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.AutoBudgetType.Set {
                        e.FieldStart("auto_budget_type")
                        s.AutoBudgetType.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyID.Set {
                        e.FieldStart("auto_budget_currency_id")
                        s.AutoBudgetCurrencyID.Encode(e)
                }
        }
        {
                if s.AutoBudgetCurrencyCode.Set {
                        e.FieldStart("auto_budget_currency_code")
                        s.AutoBudgetCurrencyCode.Encode(e)
                }
        }
        {
                if s.AutoBudgetAmount.Set {
                        e.FieldStart("auto_budget_amount")
                        s.AutoBudgetAmount.Encode(e)
                }
        }
        {
                if s.AutoBudgetPeriod.Set {
                        e.FieldStart("auto_budget_period")
                        s.AutoBudgetPeriod.Encode(e)
                }
        }
}

var jsonFieldsNameOfBudgetUpdate = [9]string{
        0: "name",
        1: "active",
        2: "order",
        3: "notes",
        4: "auto_budget_type",
        5: "auto_budget_currency_id",
        6: "auto_budget_currency_code",
        7: "auto_budget_amount",
        8: "auto_budget_period",
}

// Decode decodes BudgetUpdate from json.
func (s *BudgetUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode BudgetUpdate to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "auto_budget_type":
                        if err := func() error {
                                s.AutoBudgetType.Reset()
                                if err := s.AutoBudgetType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_type\"")
                        }
                case "auto_budget_currency_id":
                        if err := func() error {
                                s.AutoBudgetCurrencyID.Reset()
                                if err := s.AutoBudgetCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_id\"")
                        }
                case "auto_budget_currency_code":
                        if err := func() error {
                                s.AutoBudgetCurrencyCode.Reset()
                                if err := s.AutoBudgetCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_currency_code\"")
                        }
                case "auto_budget_amount":
                        if err := func() error {
                                s.AutoBudgetAmount.Reset()
                                if err := s.AutoBudgetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_amount\"")
                        }
                case "auto_budget_period":
                        if err := func() error {
                                s.AutoBudgetPeriod.Reset()
                                if err := s.AutoBudgetPeriod.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budget_period\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode BudgetUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000001,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfBudgetUpdate) {
                                        name = jsonFieldsNameOfBudgetUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *BudgetUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BudgetUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Category) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Category) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Spent != nil {
                        e.FieldStart("spent")
                        e.ArrStart()
                        for _, elem := range s.Spent {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Earned != nil {
                        e.FieldStart("earned")
                        e.ArrStart()
                        for _, elem := range s.Earned {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfCategory = [6]string{
        0: "created_at",
        1: "updated_at",
        2: "name",
        3: "notes",
        4: "spent",
        5: "earned",
}

// Decode decodes Category from json.
func (s *Category) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Category to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "spent":
                        if err := func() error {
                                s.Spent = make([]CategorySpent, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem CategorySpent
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Spent = append(s.Spent, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"spent\"")
                        }
                case "earned":
                        if err := func() error {
                                s.Earned = make([]CategoryEarned, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem CategoryEarned
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Earned = append(s.Earned, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"earned\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Category")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCategory) {
                                        name = jsonFieldsNameOfCategory[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Category) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Category) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategoryArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategoryArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfCategoryArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes CategoryArray from json.
func (s *CategoryArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategoryArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]CategoryRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem CategoryRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategoryArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCategoryArray) {
                                        name = jsonFieldsNameOfCategoryArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategoryArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategoryArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategoryEarned) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategoryEarned) encodeFields(e *jx.Encoder) {
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.Sum.Set {
                        e.FieldStart("sum")
                        s.Sum.Encode(e)
                }
        }
}

var jsonFieldsNameOfCategoryEarned = [5]string{
        0: "currency_id",
        1: "currency_code",
        2: "currency_symbol",
        3: "currency_decimal_places",
        4: "sum",
}

// Decode decodes CategoryEarned from json.
func (s *CategoryEarned) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategoryEarned to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "sum":
                        if err := func() error {
                                s.Sum.Reset()
                                if err := s.Sum.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sum\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategoryEarned")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategoryEarned) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategoryEarned) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategoryRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategoryRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfCategoryRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes CategoryRead from json.
func (s *CategoryRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategoryRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategoryRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCategoryRead) {
                                        name = jsonFieldsNameOfCategoryRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategoryRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategoryRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategorySingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategorySingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfCategorySingle = [1]string{
        0: "data",
}

// Decode decodes CategorySingle from json.
func (s *CategorySingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategorySingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategorySingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCategorySingle) {
                                        name = jsonFieldsNameOfCategorySingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategorySingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategorySingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategorySpent) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategorySpent) encodeFields(e *jx.Encoder) {
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.Sum.Set {
                        e.FieldStart("sum")
                        s.Sum.Encode(e)
                }
        }
}

var jsonFieldsNameOfCategorySpent = [5]string{
        0: "currency_id",
        1: "currency_code",
        2: "currency_symbol",
        3: "currency_decimal_places",
        4: "sum",
}

// Decode decodes CategorySpent from json.
func (s *CategorySpent) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategorySpent to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "sum":
                        if err := func() error {
                                s.Sum.Reset()
                                if err := s.Sum.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sum\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategorySpent")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategorySpent) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategorySpent) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CategoryUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CategoryUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfCategoryUpdate = [2]string{
        0: "name",
        1: "notes",
}

// Decode decodes CategoryUpdate from json.
func (s *CategoryUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CategoryUpdate to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CategoryUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCategoryUpdate) {
                                        name = jsonFieldsNameOfCategoryUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CategoryUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CategoryUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ChartDataPoint) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ChartDataPoint) encodeFields(e *jx.Encoder) {
        {
                if s.Key.Set {
                        e.FieldStart("key")
                        s.Key.Encode(e)
                }
        }
}

var jsonFieldsNameOfChartDataPoint = [1]string{
        0: "key",
}

// Decode decodes ChartDataPoint from json.
func (s *ChartDataPoint) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ChartDataPoint to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "key":
                        if err := func() error {
                                s.Key.Reset()
                                if err := s.Key.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"key\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ChartDataPoint")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ChartDataPoint) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ChartDataPoint) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ChartDataSet) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ChartDataSet) encodeFields(e *jx.Encoder) {
        {
                if s.Label.Set {
                        e.FieldStart("label")
                        s.Label.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.StartDate.Set {
                        e.FieldStart("start_date")
                        s.StartDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.EndDate.Set {
                        e.FieldStart("end_date")
                        s.EndDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.YAxisID.Set {
                        e.FieldStart("yAxisID")
                        s.YAxisID.Encode(e)
                }
        }
        {
                if s.Entries.Set {
                        e.FieldStart("entries")
                        s.Entries.Encode(e)
                }
        }
}

var jsonFieldsNameOfChartDataSet = [10]string{
        0: "label",
        1: "currency_id",
        2: "currency_code",
        3: "currency_symbol",
        4: "currency_decimal_places",
        5: "start_date",
        6: "end_date",
        7: "type",
        8: "yAxisID",
        9: "entries",
}

// Decode decodes ChartDataSet from json.
func (s *ChartDataSet) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ChartDataSet to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "label":
                        if err := func() error {
                                s.Label.Reset()
                                if err := s.Label.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"label\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "start_date":
                        if err := func() error {
                                s.StartDate.Reset()
                                if err := s.StartDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start_date\"")
                        }
                case "end_date":
                        if err := func() error {
                                s.EndDate.Reset()
                                if err := s.EndDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end_date\"")
                        }
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "yAxisID":
                        if err := func() error {
                                s.YAxisID.Reset()
                                if err := s.YAxisID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"yAxisID\"")
                        }
                case "entries":
                        if err := func() error {
                                s.Entries.Reset()
                                if err := s.Entries.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"entries\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ChartDataSet")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ChartDataSet) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ChartDataSet) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s ChartDataSetEntries) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields implements json.Marshaler.
func (s ChartDataSetEntries) encodeFields(e *jx.Encoder) {
        for k, elem := range s {
                e.FieldStart(k)

                elem.Encode(e)
        }
}

// Decode decodes ChartDataSetEntries from json.
func (s *ChartDataSetEntries) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ChartDataSetEntries to nil")
        }
        m := s.init()
        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                var elem ChartDataPoint
                if err := func() error {
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        return errors.Wrapf(err, "decode field %q", k)
                }
                m[string(k)] = elem
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ChartDataSetEntries")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ChartDataSetEntries) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ChartDataSetEntries) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ChartLine as json.
func (s ChartLine) Encode(e *jx.Encoder) {
        unwrapped := []ChartDataSet(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes ChartLine from json.
func (s *ChartLine) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ChartLine to nil")
        }
        var unwrapped []ChartDataSet
        if err := func() error {
                unwrapped = make([]ChartDataSet, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem ChartDataSet
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = ChartLine(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ChartLine) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ChartLine) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ConfigValueFilter as json.
func (s ConfigValueFilter) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes ConfigValueFilter from json.
func (s *ConfigValueFilter) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ConfigValueFilter to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch ConfigValueFilter(v) {
        case ConfigValueFilterConfigurationIsDemoSite:
                *s = ConfigValueFilterConfigurationIsDemoSite
        case ConfigValueFilterConfigurationPermissionUpdateCheck:
                *s = ConfigValueFilterConfigurationPermissionUpdateCheck
        case ConfigValueFilterConfigurationLastUpdateCheck:
                *s = ConfigValueFilterConfigurationLastUpdateCheck
        case ConfigValueFilterConfigurationSingleUserMode:
                *s = ConfigValueFilterConfigurationSingleUserMode
        case ConfigValueFilterFireflyVersion:
                *s = ConfigValueFilterFireflyVersion
        case ConfigValueFilterFireflyAPIVersion:
                *s = ConfigValueFilterFireflyAPIVersion
        case ConfigValueFilterFireflyDefaultLocation:
                *s = ConfigValueFilterFireflyDefaultLocation
        case ConfigValueFilterFireflyAccountToTransaction:
                *s = ConfigValueFilterFireflyAccountToTransaction
        case ConfigValueFilterFireflyAllowedOpposingTypes:
                *s = ConfigValueFilterFireflyAllowedOpposingTypes
        case ConfigValueFilterFireflyAccountRoles:
                *s = ConfigValueFilterFireflyAccountRoles
        case ConfigValueFilterFireflyValidLiabilities:
                *s = ConfigValueFilterFireflyValidLiabilities
        case ConfigValueFilterFireflyInterestPeriods:
                *s = ConfigValueFilterFireflyInterestPeriods
        case ConfigValueFilterFireflyEnableExternalMap:
                *s = ConfigValueFilterFireflyEnableExternalMap
        case ConfigValueFilterFireflyExpectedSourceTypes:
                *s = ConfigValueFilterFireflyExpectedSourceTypes
        case ConfigValueFilterAppTimezone:
                *s = ConfigValueFilterAppTimezone
        case ConfigValueFilterFireflyBillPeriods:
                *s = ConfigValueFilterFireflyBillPeriods
        case ConfigValueFilterFireflyCreditCardTypes:
                *s = ConfigValueFilterFireflyCreditCardTypes
        case ConfigValueFilterFireflyLanguages:
                *s = ConfigValueFilterFireflyLanguages
        case ConfigValueFilterFireflyValidViewRanges:
                *s = ConfigValueFilterFireflyValidViewRanges
        default:
                *s = ConfigValueFilter(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ConfigValueFilter) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ConfigValueFilter) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Configuration) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Configuration) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("title")
                s.Title.Encode(e)
        }
        {
                e.FieldStart("value")
                s.Value.Encode(e)
        }
        {
                e.FieldStart("editable")
                e.Bool(s.Editable)
        }
}

var jsonFieldsNameOfConfiguration = [3]string{
        0: "title",
        1: "value",
        2: "editable",
}

// Decode decodes Configuration from json.
func (s *Configuration) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Configuration to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "value":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "editable":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Bool()
                                s.Editable = bool(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"editable\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Configuration")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfConfiguration) {
                                        name = jsonFieldsNameOfConfiguration[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Configuration) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Configuration) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ConfigurationArray as json.
func (s ConfigurationArray) Encode(e *jx.Encoder) {
        unwrapped := []Configuration(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes ConfigurationArray from json.
func (s *ConfigurationArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ConfigurationArray to nil")
        }
        var unwrapped []Configuration
        if err := func() error {
                unwrapped = make([]Configuration, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem Configuration
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = ConfigurationArray(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ConfigurationArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ConfigurationArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ConfigurationSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ConfigurationSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfConfigurationSingle = [1]string{
        0: "data",
}

// Decode decodes ConfigurationSingle from json.
func (s *ConfigurationSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ConfigurationSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ConfigurationSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfConfigurationSingle) {
                                        name = jsonFieldsNameOfConfigurationSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ConfigurationSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ConfigurationSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ConfigurationUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ConfigurationUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("value")
                s.Value.Encode(e)
        }
}

var jsonFieldsNameOfConfigurationUpdate = [1]string{
        0: "value",
}

// Decode decodes ConfigurationUpdate from json.
func (s *ConfigurationUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ConfigurationUpdate to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "value":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ConfigurationUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfConfigurationUpdate) {
                                        name = jsonFieldsNameOfConfigurationUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ConfigurationUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ConfigurationUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes CreditCardType as json.
func (s CreditCardType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes CreditCardType from json.
func (s *CreditCardType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CreditCardType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch CreditCardType(v) {
        case CreditCardTypeMonthlyFull:
                *s = CreditCardTypeMonthlyFull
        default:
                *s = CreditCardType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s CreditCardType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreditCardType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CronResult) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CronResult) encodeFields(e *jx.Encoder) {
        {
                if s.RecurringTransactions.Set {
                        e.FieldStart("recurring_transactions")
                        s.RecurringTransactions.Encode(e)
                }
        }
        {
                if s.AutoBudgets.Set {
                        e.FieldStart("auto_budgets")
                        s.AutoBudgets.Encode(e)
                }
        }
        {
                if s.Telemetry.Set {
                        e.FieldStart("telemetry")
                        s.Telemetry.Encode(e)
                }
        }
}

var jsonFieldsNameOfCronResult = [3]string{
        0: "recurring_transactions",
        1: "auto_budgets",
        2: "telemetry",
}

// Decode decodes CronResult from json.
func (s *CronResult) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CronResult to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "recurring_transactions":
                        if err := func() error {
                                s.RecurringTransactions.Reset()
                                if err := s.RecurringTransactions.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"recurring_transactions\"")
                        }
                case "auto_budgets":
                        if err := func() error {
                                s.AutoBudgets.Reset()
                                if err := s.AutoBudgets.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"auto_budgets\"")
                        }
                case "telemetry":
                        if err := func() error {
                                s.Telemetry.Reset()
                                if err := s.Telemetry.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"telemetry\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CronResult")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CronResult) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CronResult) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CronResultRow) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CronResultRow) encodeFields(e *jx.Encoder) {
        {
                if s.JobFired.Set {
                        e.FieldStart("job_fired")
                        s.JobFired.Encode(e)
                }
        }
        {
                if s.JobSucceeded.Set {
                        e.FieldStart("job_succeeded")
                        s.JobSucceeded.Encode(e)
                }
        }
        {
                if s.JobErrored.Set {
                        e.FieldStart("job_errored")
                        s.JobErrored.Encode(e)
                }
        }
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
}

var jsonFieldsNameOfCronResultRow = [4]string{
        0: "job_fired",
        1: "job_succeeded",
        2: "job_errored",
        3: "message",
}

// Decode decodes CronResultRow from json.
func (s *CronResultRow) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CronResultRow to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "job_fired":
                        if err := func() error {
                                s.JobFired.Reset()
                                if err := s.JobFired.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"job_fired\"")
                        }
                case "job_succeeded":
                        if err := func() error {
                                s.JobSucceeded.Reset()
                                if err := s.JobSucceeded.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"job_succeeded\"")
                        }
                case "job_errored":
                        if err := func() error {
                                s.JobErrored.Reset()
                                if err := s.JobErrored.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"job_errored\"")
                        }
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CronResultRow")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CronResultRow) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CronResultRow) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Currency) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Currency) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Enabled.Set {
                        e.FieldStart("enabled")
                        s.Enabled.Encode(e)
                }
        }
        {
                if s.Default.Set {
                        e.FieldStart("default")
                        s.Default.Encode(e)
                }
        }
        {
                e.FieldStart("code")
                e.Str(s.Code)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("symbol")
                e.Str(s.Symbol)
        }
        {
                if s.DecimalPlaces.Set {
                        e.FieldStart("decimal_places")
                        s.DecimalPlaces.Encode(e)
                }
        }
}

var jsonFieldsNameOfCurrency = [8]string{
        0: "created_at",
        1: "updated_at",
        2: "enabled",
        3: "default",
        4: "code",
        5: "name",
        6: "symbol",
        7: "decimal_places",
}

// Decode decodes Currency from json.
func (s *Currency) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Currency to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "enabled":
                        if err := func() error {
                                s.Enabled.Reset()
                                if err := s.Enabled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"enabled\"")
                        }
                case "default":
                        if err := func() error {
                                s.Default.Reset()
                                if err := s.Default.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"default\"")
                        }
                case "code":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Code = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"code\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "symbol":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.Symbol = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"symbol\"")
                        }
                case "decimal_places":
                        if err := func() error {
                                s.DecimalPlaces.Reset()
                                if err := s.DecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Currency")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b01110000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCurrency) {
                                        name = jsonFieldsNameOfCurrency[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Currency) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Currency) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CurrencyArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CurrencyArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfCurrencyArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes CurrencyArray from json.
func (s *CurrencyArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencyArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]CurrencyRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem CurrencyRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CurrencyArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCurrencyArray) {
                                        name = jsonFieldsNameOfCurrencyArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CurrencyArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencyArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CurrencyRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CurrencyRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfCurrencyRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes CurrencyRead from json.
func (s *CurrencyRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencyRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CurrencyRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCurrencyRead) {
                                        name = jsonFieldsNameOfCurrencyRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CurrencyRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencyRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CurrencySingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CurrencySingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfCurrencySingle = [1]string{
        0: "data",
}

// Decode decodes CurrencySingle from json.
func (s *CurrencySingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencySingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CurrencySingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCurrencySingle) {
                                        name = jsonFieldsNameOfCurrencySingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CurrencySingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencySingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CurrencyStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CurrencyStore) encodeFields(e *jx.Encoder) {
        {
                if s.Enabled.Set {
                        e.FieldStart("enabled")
                        s.Enabled.Encode(e)
                }
        }
        {
                if s.Default.Set {
                        e.FieldStart("default")
                        s.Default.Encode(e)
                }
        }
        {
                e.FieldStart("code")
                e.Str(s.Code)
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("symbol")
                e.Str(s.Symbol)
        }
        {
                if s.DecimalPlaces.Set {
                        e.FieldStart("decimal_places")
                        s.DecimalPlaces.Encode(e)
                }
        }
}

var jsonFieldsNameOfCurrencyStore = [6]string{
        0: "enabled",
        1: "default",
        2: "code",
        3: "name",
        4: "symbol",
        5: "decimal_places",
}

// Decode decodes CurrencyStore from json.
func (s *CurrencyStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencyStore to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "enabled":
                        if err := func() error {
                                s.Enabled.Reset()
                                if err := s.Enabled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"enabled\"")
                        }
                case "default":
                        if err := func() error {
                                s.Default.Reset()
                                if err := s.Default.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"default\"")
                        }
                case "code":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Code = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"code\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "symbol":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Symbol = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"symbol\"")
                        }
                case "decimal_places":
                        if err := func() error {
                                s.DecimalPlaces.Reset()
                                if err := s.DecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CurrencyStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00011100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfCurrencyStore) {
                                        name = jsonFieldsNameOfCurrencyStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CurrencyStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencyStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CurrencyUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CurrencyUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Enabled.Set {
                        e.FieldStart("enabled")
                        s.Enabled.Encode(e)
                }
        }
        {
                if s.Default.Set {
                        e.FieldStart("default")
                        s.Default.Encode(e)
                }
        }
        {
                if s.Code.Set {
                        e.FieldStart("code")
                        s.Code.Encode(e)
                }
        }
        {
                if s.Name.Set {
                        e.FieldStart("name")
                        s.Name.Encode(e)
                }
        }
        {
                if s.Symbol.Set {
                        e.FieldStart("symbol")
                        s.Symbol.Encode(e)
                }
        }
        {
                if s.DecimalPlaces.Set {
                        e.FieldStart("decimal_places")
                        s.DecimalPlaces.Encode(e)
                }
        }
}

var jsonFieldsNameOfCurrencyUpdate = [6]string{
        0: "enabled",
        1: "default",
        2: "code",
        3: "name",
        4: "symbol",
        5: "decimal_places",
}

// Decode decodes CurrencyUpdate from json.
func (s *CurrencyUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencyUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "enabled":
                        if err := func() error {
                                s.Enabled.Reset()
                                if err := s.Enabled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"enabled\"")
                        }
                case "default":
                        if err := func() error {
                                s.Default.Reset()
                                if err := s.Default.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"default\"")
                        }
                case "code":
                        if err := func() error {
                                s.Code.Reset()
                                if err := s.Code.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"code\"")
                        }
                case "name":
                        if err := func() error {
                                s.Name.Reset()
                                if err := s.Name.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "symbol":
                        if err := func() error {
                                s.Symbol.Reset()
                                if err := s.Symbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"symbol\"")
                        }
                case "decimal_places":
                        if err := func() error {
                                s.DecimalPlaces.Reset()
                                if err := s.DecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"decimal_places\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode CurrencyUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CurrencyUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencyUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes CurrencyUpdateDefault as json.
func (s CurrencyUpdateDefault) Encode(e *jx.Encoder) {
        e.Bool(bool(s))
}

// Decode decodes CurrencyUpdateDefault from json.
func (s *CurrencyUpdateDefault) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode CurrencyUpdateDefault to nil")
        }
        v, err := d.Bool()
        if err != nil {
                return err
        }
        *s = CurrencyUpdateDefault(v)

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s CurrencyUpdateDefault) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CurrencyUpdateDefault) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes InsightGroup as json.
func (s InsightGroup) Encode(e *jx.Encoder) {
        unwrapped := []InsightGroupEntry(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes InsightGroup from json.
func (s *InsightGroup) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightGroup to nil")
        }
        var unwrapped []InsightGroupEntry
        if err := func() error {
                unwrapped = make([]InsightGroupEntry, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem InsightGroupEntry
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = InsightGroup(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s InsightGroup) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightGroup) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *InsightGroupEntry) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *InsightGroupEntry) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                if s.Name.Set {
                        e.FieldStart("name")
                        s.Name.Encode(e)
                }
        }
        {
                if s.Difference.Set {
                        e.FieldStart("difference")
                        s.Difference.Encode(e)
                }
        }
        {
                if s.DifferenceFloat.Set {
                        e.FieldStart("difference_float")
                        s.DifferenceFloat.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
}

var jsonFieldsNameOfInsightGroupEntry = [6]string{
        0: "id",
        1: "name",
        2: "difference",
        3: "difference_float",
        4: "currency_id",
        5: "currency_code",
}

// Decode decodes InsightGroupEntry from json.
func (s *InsightGroupEntry) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightGroupEntry to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        if err := func() error {
                                s.Name.Reset()
                                if err := s.Name.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "difference":
                        if err := func() error {
                                s.Difference.Reset()
                                if err := s.Difference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference\"")
                        }
                case "difference_float":
                        if err := func() error {
                                s.DifferenceFloat.Reset()
                                if err := s.DifferenceFloat.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference_float\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode InsightGroupEntry")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *InsightGroupEntry) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightGroupEntry) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes InsightTotal as json.
func (s InsightTotal) Encode(e *jx.Encoder) {
        unwrapped := []InsightTotalEntry(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes InsightTotal from json.
func (s *InsightTotal) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightTotal to nil")
        }
        var unwrapped []InsightTotalEntry
        if err := func() error {
                unwrapped = make([]InsightTotalEntry, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem InsightTotalEntry
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = InsightTotal(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s InsightTotal) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightTotal) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *InsightTotalEntry) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *InsightTotalEntry) encodeFields(e *jx.Encoder) {
        {
                if s.Difference.Set {
                        e.FieldStart("difference")
                        s.Difference.Encode(e)
                }
        }
        {
                if s.DifferenceFloat.Set {
                        e.FieldStart("difference_float")
                        s.DifferenceFloat.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
}

var jsonFieldsNameOfInsightTotalEntry = [4]string{
        0: "difference",
        1: "difference_float",
        2: "currency_id",
        3: "currency_code",
}

// Decode decodes InsightTotalEntry from json.
func (s *InsightTotalEntry) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightTotalEntry to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "difference":
                        if err := func() error {
                                s.Difference.Reset()
                                if err := s.Difference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference\"")
                        }
                case "difference_float":
                        if err := func() error {
                                s.DifferenceFloat.Reset()
                                if err := s.DifferenceFloat.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference_float\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode InsightTotalEntry")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *InsightTotalEntry) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightTotalEntry) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes InsightTransfer as json.
func (s InsightTransfer) Encode(e *jx.Encoder) {
        unwrapped := []InsightTransferEntry(s)

        e.ArrStart()
        for _, elem := range unwrapped {
                elem.Encode(e)
        }
        e.ArrEnd()
}

// Decode decodes InsightTransfer from json.
func (s *InsightTransfer) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightTransfer to nil")
        }
        var unwrapped []InsightTransferEntry
        if err := func() error {
                unwrapped = make([]InsightTransferEntry, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem InsightTransferEntry
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        unwrapped = append(unwrapped, elem)
                        return nil
                }); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = InsightTransfer(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s InsightTransfer) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightTransfer) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *InsightTransferEntry) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *InsightTransferEntry) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                if s.Name.Set {
                        e.FieldStart("name")
                        s.Name.Encode(e)
                }
        }
        {
                if s.Difference.Set {
                        e.FieldStart("difference")
                        s.Difference.Encode(e)
                }
        }
        {
                if s.DifferenceFloat.Set {
                        e.FieldStart("difference_float")
                        s.DifferenceFloat.Encode(e)
                }
        }
        {
                if s.In.Set {
                        e.FieldStart("in")
                        s.In.Encode(e)
                }
        }
        {
                if s.InFloat.Set {
                        e.FieldStart("in_float")
                        s.InFloat.Encode(e)
                }
        }
        {
                if s.Out.Set {
                        e.FieldStart("out")
                        s.Out.Encode(e)
                }
        }
        {
                if s.OutFloat.Set {
                        e.FieldStart("out_float")
                        s.OutFloat.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
}

var jsonFieldsNameOfInsightTransferEntry = [10]string{
        0: "id",
        1: "name",
        2: "difference",
        3: "difference_float",
        4: "in",
        5: "in_float",
        6: "out",
        7: "out_float",
        8: "currency_id",
        9: "currency_code",
}

// Decode decodes InsightTransferEntry from json.
func (s *InsightTransferEntry) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InsightTransferEntry to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "name":
                        if err := func() error {
                                s.Name.Reset()
                                if err := s.Name.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "difference":
                        if err := func() error {
                                s.Difference.Reset()
                                if err := s.Difference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference\"")
                        }
                case "difference_float":
                        if err := func() error {
                                s.DifferenceFloat.Reset()
                                if err := s.DifferenceFloat.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"difference_float\"")
                        }
                case "in":
                        if err := func() error {
                                s.In.Reset()
                                if err := s.In.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"in\"")
                        }
                case "in_float":
                        if err := func() error {
                                s.InFloat.Reset()
                                if err := s.InFloat.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"in_float\"")
                        }
                case "out":
                        if err := func() error {
                                s.Out.Reset()
                                if err := s.Out.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"out\"")
                        }
                case "out_float":
                        if err := func() error {
                                s.OutFloat.Reset()
                                if err := s.OutFloat.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"out_float\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode InsightTransferEntry")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *InsightTransferEntry) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InsightTransferEntry) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes InterestPeriod as json.
func (s InterestPeriod) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes InterestPeriod from json.
func (s *InterestPeriod) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InterestPeriod to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch InterestPeriod(v) {
        case InterestPeriodWeekly:
                *s = InterestPeriodWeekly
        case InterestPeriodMonthly:
                *s = InterestPeriodMonthly
        case InterestPeriodQuarterly:
                *s = InterestPeriodQuarterly
        case InterestPeriodHalfYear:
                *s = InterestPeriodHalfYear
        case InterestPeriodYearly:
                *s = InterestPeriodYearly
        default:
                *s = InterestPeriod(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s InterestPeriod) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InterestPeriod) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *InternalException) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *InternalException) encodeFields(e *jx.Encoder) {
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
        {
                if s.Exception.Set {
                        e.FieldStart("exception")
                        s.Exception.Encode(e)
                }
        }
}

var jsonFieldsNameOfInternalException = [2]string{
        0: "message",
        1: "exception",
}

// Decode decodes InternalException from json.
func (s *InternalException) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode InternalException to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                case "exception":
                        if err := func() error {
                                s.Exception.Reset()
                                if err := s.Exception.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"exception\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode InternalException")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *InternalException) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *InternalException) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes LiabilityDirection as json.
func (s LiabilityDirection) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes LiabilityDirection from json.
func (s *LiabilityDirection) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LiabilityDirection to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch LiabilityDirection(v) {
        case LiabilityDirectionCredit:
                *s = LiabilityDirectionCredit
        case LiabilityDirectionDebit:
                *s = LiabilityDirectionDebit
        default:
                *s = LiabilityDirection(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s LiabilityDirection) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LiabilityDirection) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes LiabilityType as json.
func (s LiabilityType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes LiabilityType from json.
func (s *LiabilityType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LiabilityType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch LiabilityType(v) {
        case LiabilityTypeLoan:
                *s = LiabilityTypeLoan
        case LiabilityTypeDebt:
                *s = LiabilityTypeDebt
        case LiabilityTypeMortgage:
                *s = LiabilityTypeMortgage
        default:
                *s = LiabilityType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s LiabilityType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LiabilityType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *LinkType) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *LinkType) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("inward")
                e.Str(s.Inward)
        }
        {
                e.FieldStart("outward")
                e.Str(s.Outward)
        }
        {
                if s.Editable.Set {
                        e.FieldStart("editable")
                        s.Editable.Encode(e)
                }
        }
}

var jsonFieldsNameOfLinkType = [4]string{
        0: "name",
        1: "inward",
        2: "outward",
        3: "editable",
}

// Decode decodes LinkType from json.
func (s *LinkType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LinkType to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "inward":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Inward = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"inward\"")
                        }
                case "outward":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Outward = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"outward\"")
                        }
                case "editable":
                        if err := func() error {
                                s.Editable.Reset()
                                if err := s.Editable.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"editable\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode LinkType")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfLinkType) {
                                        name = jsonFieldsNameOfLinkType[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *LinkType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *LinkTypeArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *LinkTypeArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfLinkTypeArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes LinkTypeArray from json.
func (s *LinkTypeArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LinkTypeArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]LinkTypeRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem LinkTypeRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode LinkTypeArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfLinkTypeArray) {
                                        name = jsonFieldsNameOfLinkTypeArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *LinkTypeArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkTypeArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *LinkTypeRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *LinkTypeRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfLinkTypeRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes LinkTypeRead from json.
func (s *LinkTypeRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LinkTypeRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode LinkTypeRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfLinkTypeRead) {
                                        name = jsonFieldsNameOfLinkTypeRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *LinkTypeRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkTypeRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *LinkTypeSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *LinkTypeSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfLinkTypeSingle = [1]string{
        0: "data",
}

// Decode decodes LinkTypeSingle from json.
func (s *LinkTypeSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LinkTypeSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode LinkTypeSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfLinkTypeSingle) {
                                        name = jsonFieldsNameOfLinkTypeSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *LinkTypeSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkTypeSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *LinkTypeUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *LinkTypeUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Name.Set {
                        e.FieldStart("name")
                        s.Name.Encode(e)
                }
        }
        {
                if s.Inward.Set {
                        e.FieldStart("inward")
                        s.Inward.Encode(e)
                }
        }
        {
                if s.Outward.Set {
                        e.FieldStart("outward")
                        s.Outward.Encode(e)
                }
        }
}

var jsonFieldsNameOfLinkTypeUpdate = [3]string{
        0: "name",
        1: "inward",
        2: "outward",
}

// Decode decodes LinkTypeUpdate from json.
func (s *LinkTypeUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode LinkTypeUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        if err := func() error {
                                s.Name.Reset()
                                if err := s.Name.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "inward":
                        if err := func() error {
                                s.Inward.Reset()
                                if err := s.Inward.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"inward\"")
                        }
                case "outward":
                        if err := func() error {
                                s.Outward.Reset()
                                if err := s.Outward.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"outward\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode LinkTypeUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *LinkTypeUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LinkTypeUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Meta) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Meta) encodeFields(e *jx.Encoder) {
        {
                if s.Pagination.Set {
                        e.FieldStart("pagination")
                        s.Pagination.Encode(e)
                }
        }
}

var jsonFieldsNameOfMeta = [1]string{
        0: "pagination",
}

// Decode decodes Meta from json.
func (s *Meta) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Meta to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "pagination":
                        if err := func() error {
                                s.Pagination.Reset()
                                if err := s.Pagination.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"pagination\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Meta")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Meta) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Meta) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MetaPagination) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MetaPagination) encodeFields(e *jx.Encoder) {
        {
                if s.Total.Set {
                        e.FieldStart("total")
                        s.Total.Encode(e)
                }
        }
        {
                if s.Count.Set {
                        e.FieldStart("count")
                        s.Count.Encode(e)
                }
        }
        {
                if s.PerPage.Set {
                        e.FieldStart("per_page")
                        s.PerPage.Encode(e)
                }
        }
        {
                if s.CurrentPage.Set {
                        e.FieldStart("current_page")
                        s.CurrentPage.Encode(e)
                }
        }
        {
                if s.TotalPages.Set {
                        e.FieldStart("total_pages")
                        s.TotalPages.Encode(e)
                }
        }
}

var jsonFieldsNameOfMetaPagination = [5]string{
        0: "total",
        1: "count",
        2: "per_page",
        3: "current_page",
        4: "total_pages",
}

// Decode decodes MetaPagination from json.
func (s *MetaPagination) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode MetaPagination to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "total":
                        if err := func() error {
                                s.Total.Reset()
                                if err := s.Total.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"total\"")
                        }
                case "count":
                        if err := func() error {
                                s.Count.Reset()
                                if err := s.Count.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"count\"")
                        }
                case "per_page":
                        if err := func() error {
                                s.PerPage.Reset()
                                if err := s.PerPage.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"per_page\"")
                        }
                case "current_page":
                        if err := func() error {
                                s.CurrentPage.Reset()
                                if err := s.CurrentPage.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_page\"")
                        }
                case "total_pages":
                        if err := func() error {
                                s.TotalPages.Reset()
                                if err := s.TotalPages.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"total_pages\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode MetaPagination")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MetaPagination) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MetaPagination) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes time.Time as json.
func (o NilDate) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
        if o.Null {
                e.Null()
                return
        }
        format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *NilDate) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
        if o == nil {
                return errors.New("invalid: unable to decode NilDate to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v time.Time
                o.Value = v
                o.Null = true
                return nil
        }
        o.Null = false
        v, err := format(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s NilDate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e, json.EncodeDate)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *NilDate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d, json.DecodeDate)
}

// Encode encodes string as json.
func (o NilString) Encode(e *jx.Encoder) {
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes string from json.
func (o *NilString) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode NilString to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v string
                o.Value = v
                o.Null = true
                return nil
        }
        o.Null = false
        v, err := d.Str()
        if err != nil {
                return err
        }
        o.Value = string(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s NilString) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *NilString) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *NotFound) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *NotFound) encodeFields(e *jx.Encoder) {
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
        {
                if s.Exception.Set {
                        e.FieldStart("exception")
                        s.Exception.Encode(e)
                }
        }
}

var jsonFieldsNameOfNotFound = [2]string{
        0: "message",
        1: "exception",
}

// Decode decodes NotFound from json.
func (s *NotFound) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode NotFound to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                case "exception":
                        if err := func() error {
                                s.Exception.Reset()
                                if err := s.Exception.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"exception\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode NotFound")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *NotFound) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *NotFound) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectGroup) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectGroup) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                e.FieldStart("order")
                e.Int32(s.Order)
        }
}

var jsonFieldsNameOfObjectGroup = [4]string{
        0: "created_at",
        1: "updated_at",
        2: "title",
        3: "order",
}

// Decode decodes ObjectGroup from json.
func (s *ObjectGroup) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectGroup to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "order":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Int32()
                                s.Order = int32(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectGroup")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfObjectGroup) {
                                        name = jsonFieldsNameOfObjectGroup[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectGroup) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectGroup) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectGroupArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectGroupArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfObjectGroupArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes ObjectGroupArray from json.
func (s *ObjectGroupArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectGroupArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]ObjectGroupRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem ObjectGroupRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectGroupArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfObjectGroupArray) {
                                        name = jsonFieldsNameOfObjectGroupArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectGroupArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectGroupArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectGroupRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectGroupRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfObjectGroupRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes ObjectGroupRead from json.
func (s *ObjectGroupRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectGroupRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectGroupRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfObjectGroupRead) {
                                        name = jsonFieldsNameOfObjectGroupRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectGroupRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectGroupRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectGroupSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectGroupSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfObjectGroupSingle = [1]string{
        0: "data",
}

// Decode decodes ObjectGroupSingle from json.
func (s *ObjectGroupSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectGroupSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectGroupSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfObjectGroupSingle) {
                                        name = jsonFieldsNameOfObjectGroupSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectGroupSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectGroupSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectGroupUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectGroupUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
}

var jsonFieldsNameOfObjectGroupUpdate = [2]string{
        0: "title",
        1: "order",
}

// Decode decodes ObjectGroupUpdate from json.
func (s *ObjectGroupUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectGroupUpdate to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectGroupUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfObjectGroupUpdate) {
                                        name = jsonFieldsNameOfObjectGroupUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectGroupUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectGroupUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectLink) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectLink) encodeFields(e *jx.Encoder) {
        {
                if s.R0.Set {
                        e.FieldStart("0")
                        s.R0.Encode(e)
                }
        }
        {
                if s.Self.Set {
                        e.FieldStart("self")
                        s.Self.Encode(e)
                }
        }
}

var jsonFieldsNameOfObjectLink = [2]string{
        0: "0",
        1: "self",
}

// Decode decodes ObjectLink from json.
func (s *ObjectLink) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectLink to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "0":
                        if err := func() error {
                                s.R0.Reset()
                                if err := s.R0.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"0\"")
                        }
                case "self":
                        if err := func() error {
                                s.Self.Reset()
                                if err := s.Self.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"self\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectLink")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectLink) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectLink) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ObjectLink0) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ObjectLink0) encodeFields(e *jx.Encoder) {
        {
                if s.Rel.Set {
                        e.FieldStart("rel")
                        s.Rel.Encode(e)
                }
        }
        {
                if s.URI.Set {
                        e.FieldStart("uri")
                        s.URI.Encode(e)
                }
        }
}

var jsonFieldsNameOfObjectLink0 = [2]string{
        0: "rel",
        1: "uri",
}

// Decode decodes ObjectLink0 from json.
func (s *ObjectLink0) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ObjectLink0 to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "rel":
                        if err := func() error {
                                s.Rel.Reset()
                                if err := s.Rel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rel\"")
                        }
                case "uri":
                        if err := func() error {
                                s.URI.Reset()
                                if err := s.URI.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"uri\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ObjectLink0")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ObjectLink0) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ObjectLink0) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AccountTypeProperty as json.
func (o OptAccountTypeProperty) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes AccountTypeProperty from json.
func (o *OptAccountTypeProperty) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptAccountTypeProperty to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptAccountTypeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptAccountTypeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes BillRepeatFrequency as json.
func (o OptBillRepeatFrequency) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes BillRepeatFrequency from json.
func (o *OptBillRepeatFrequency) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptBillRepeatFrequency to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptBillRepeatFrequency) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBillRepeatFrequency) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes bool as json.
func (o OptBool) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Bool(bool(o.Value))
}

// Decode decodes bool from json.
func (o *OptBool) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptBool to nil")
        }
        o.Set = true
        v, err := d.Bool()
        if err != nil {
                return err
        }
        o.Value = bool(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptBool) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBool) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ChartDataSetEntries as json.
func (o OptChartDataSetEntries) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes ChartDataSetEntries from json.
func (o *OptChartDataSetEntries) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptChartDataSetEntries to nil")
        }
        o.Set = true
        o.Value = make(ChartDataSetEntries)
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptChartDataSetEntries) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptChartDataSetEntries) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes CronResultRow as json.
func (o OptCronResultRow) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes CronResultRow from json.
func (o *OptCronResultRow) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptCronResultRow to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptCronResultRow) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptCronResultRow) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes CurrencyUpdateDefault as json.
func (o OptCurrencyUpdateDefault) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Bool(bool(o.Value))
}

// Decode decodes CurrencyUpdateDefault from json.
func (o *OptCurrencyUpdateDefault) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptCurrencyUpdateDefault to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptCurrencyUpdateDefault) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptCurrencyUpdateDefault) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes time.Time as json.
func (o OptDate) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
        if !o.Set {
                return
        }
        format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *OptDate) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptDate to nil")
        }
        o.Set = true
        v, err := format(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptDate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e, json.EncodeDate)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d, json.DecodeDate)
}

// Encode encodes time.Time as json.
func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
        if !o.Set {
                return
        }
        format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptDateTime to nil")
        }
        o.Set = true
        v, err := format(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptDateTime) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e, json.EncodeDateTime)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDateTime) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d, json.DecodeDateTime)
}

// Encode encodes float64 as json.
func (o OptFloat64) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Float64(float64(o.Value))
}

// Decode decodes float64 from json.
func (o *OptFloat64) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptFloat64 to nil")
        }
        o.Set = true
        v, err := d.Float64()
        if err != nil {
                return err
        }
        o.Value = float64(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptFloat64) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFloat64) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes int as json.
func (o OptInt) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Int(int(o.Value))
}

// Decode decodes int from json.
func (o *OptInt) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptInt to nil")
        }
        o.Set = true
        v, err := d.Int()
        if err != nil {
                return err
        }
        o.Value = int(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptInt) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes int32 as json.
func (o OptInt32) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Int32(int32(o.Value))
}

// Decode decodes int32 from json.
func (o *OptInt32) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptInt32 to nil")
        }
        o.Set = true
        v, err := d.Int32()
        if err != nil {
                return err
        }
        o.Value = int32(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptInt32) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt32) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes MetaPagination as json.
func (o OptMetaPagination) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes MetaPagination from json.
func (o *OptMetaPagination) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptMetaPagination to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptMetaPagination) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptMetaPagination) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AccountRoleProperty as json.
func (o OptNilAccountRoleProperty) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes AccountRoleProperty from json.
func (o *OptNilAccountRoleProperty) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilAccountRoleProperty to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v AccountRoleProperty
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilAccountRoleProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilAccountRoleProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutoBudgetPeriod as json.
func (o OptNilAutoBudgetPeriod) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes AutoBudgetPeriod from json.
func (o *OptNilAutoBudgetPeriod) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilAutoBudgetPeriod to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v AutoBudgetPeriod
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilAutoBudgetPeriod) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilAutoBudgetPeriod) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes AutoBudgetType as json.
func (o OptNilAutoBudgetType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes AutoBudgetType from json.
func (o *OptNilAutoBudgetType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilAutoBudgetType to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v AutoBudgetType
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilAutoBudgetType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilAutoBudgetType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes bool as json.
func (o OptNilBool) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Bool(bool(o.Value))
}

// Decode decodes bool from json.
func (o *OptNilBool) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilBool to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v bool
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := d.Bool()
        if err != nil {
                return err
        }
        o.Value = bool(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilBool) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilBool) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes CreditCardType as json.
func (o OptNilCreditCardType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes CreditCardType from json.
func (o *OptNilCreditCardType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilCreditCardType to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v CreditCardType
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilCreditCardType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilCreditCardType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes time.Time as json.
func (o OptNilDate) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *OptNilDate) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilDate to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v time.Time
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := format(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e, json.EncodeDate)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d, json.DecodeDate)
}

// Encode encodes time.Time as json.
func (o OptNilDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *OptNilDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilDateTime to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v time.Time
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := format(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDateTime) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e, json.EncodeDateTime)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDateTime) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d, json.DecodeDateTime)
}

// Encode encodes float32 as json.
func (o OptNilFloat32) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Float32(float32(o.Value))
}

// Decode decodes float32 from json.
func (o *OptNilFloat32) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilFloat32 to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v float32
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := d.Float32()
        if err != nil {
                return err
        }
        o.Value = float32(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilFloat32) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilFloat32) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes float64 as json.
func (o OptNilFloat64) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Float64(float64(o.Value))
}

// Decode decodes float64 from json.
func (o *OptNilFloat64) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilFloat64 to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v float64
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := d.Float64()
        if err != nil {
                return err
        }
        o.Value = float64(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilFloat64) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilFloat64) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes int32 as json.
func (o OptNilInt32) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Int32(int32(o.Value))
}

// Decode decodes int32 from json.
func (o *OptNilInt32) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilInt32 to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v int32
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := d.Int32()
        if err != nil {
                return err
        }
        o.Value = int32(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilInt32) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilInt32) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes InterestPeriod as json.
func (o OptNilInterestPeriod) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes InterestPeriod from json.
func (o *OptNilInterestPeriod) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilInterestPeriod to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v InterestPeriod
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilInterestPeriod) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilInterestPeriod) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes LiabilityDirection as json.
func (o OptNilLiabilityDirection) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes LiabilityDirection from json.
func (o *OptNilLiabilityDirection) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilLiabilityDirection to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v LiabilityDirection
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilLiabilityDirection) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilLiabilityDirection) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes LiabilityType as json.
func (o OptNilLiabilityType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes LiabilityType from json.
func (o *OptNilLiabilityType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilLiabilityType to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v LiabilityType
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilLiabilityType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilLiabilityType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes string as json.
func (o OptNilString) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes string from json.
func (o *OptNilString) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilString to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v string
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        v, err := d.Str()
        if err != nil {
                return err
        }
        o.Value = string(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilString) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilString) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes []string as json.
func (o OptNilStringArray) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.ArrStart()
        for _, elem := range o.Value {
                e.Str(elem)
        }
        e.ArrEnd()
}

// Decode decodes []string from json.
func (o *OptNilStringArray) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilStringArray to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v []string
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        o.Value = make([]string, 0)
        if err := d.Arr(func(d *jx.Decoder) error {
                var elem string
                v, err := d.Str()
                elem = string(v)
                if err != nil {
                        return err
                }
                o.Value = append(o.Value, elem)
                return nil
        }); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilStringArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilStringArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes UserBlockedCodeProperty as json.
func (o OptNilUserBlockedCodeProperty) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes UserBlockedCodeProperty from json.
func (o *OptNilUserBlockedCodeProperty) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilUserBlockedCodeProperty to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v UserBlockedCodeProperty
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilUserBlockedCodeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilUserBlockedCodeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes UserRoleProperty as json.
func (o OptNilUserRoleProperty) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        if o.Null {
                e.Null()
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes UserRoleProperty from json.
func (o *OptNilUserRoleProperty) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptNilUserRoleProperty to nil")
        }
        if d.Next() == jx.Null {
                if err := d.Null(); err != nil {
                        return err
                }

                var v UserRoleProperty
                o.Value = v
                o.Set = true
                o.Null = true
                return nil
        }
        o.Set = true
        o.Null = false
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptNilUserRoleProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilUserRoleProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ObjectLink0 as json.
func (o OptObjectLink0) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes ObjectLink0 from json.
func (o *OptObjectLink0) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptObjectLink0 to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptObjectLink0) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptObjectLink0) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RecurrenceRepetitionType as json.
func (o OptRecurrenceRepetitionType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes RecurrenceRepetitionType from json.
func (o *OptRecurrenceRepetitionType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptRecurrenceRepetitionType to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptRecurrenceRepetitionType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRecurrenceRepetitionType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RecurrenceTransactionType as json.
func (o OptRecurrenceTransactionType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes RecurrenceTransactionType from json.
func (o *OptRecurrenceTransactionType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptRecurrenceTransactionType to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptRecurrenceTransactionType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRecurrenceTransactionType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleActionKeyword as json.
func (o OptRuleActionKeyword) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes RuleActionKeyword from json.
func (o *OptRuleActionKeyword) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptRuleActionKeyword to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptRuleActionKeyword) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRuleActionKeyword) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleTriggerKeyword as json.
func (o OptRuleTriggerKeyword) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes RuleTriggerKeyword from json.
func (o *OptRuleTriggerKeyword) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptRuleTriggerKeyword to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptRuleTriggerKeyword) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRuleTriggerKeyword) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleTriggerType as json.
func (o OptRuleTriggerType) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes RuleTriggerType from json.
func (o *OptRuleTriggerType) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptRuleTriggerType to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptRuleTriggerType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRuleTriggerType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptString to nil")
        }
        o.Set = true
        v, err := d.Str()
        if err != nil {
                return err
        }
        o.Value = string(v)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes SystemInfoData as json.
func (o OptSystemInfoData) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes SystemInfoData from json.
func (o *OptSystemInfoData) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptSystemInfoData to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptSystemInfoData) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptSystemInfoData) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes TransactionTypeProperty as json.
func (o OptTransactionTypeProperty) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes TransactionTypeProperty from json.
func (o *OptTransactionTypeProperty) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptTransactionTypeProperty to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptTransactionTypeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptTransactionTypeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes url.URL as json.
func (o OptURI) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        json.EncodeURI(e, o.Value)
}

// Decode decodes url.URL from json.
func (o *OptURI) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptURI to nil")
        }
        o.Set = true
        v, err := json.DecodeURI(d)
        if err != nil {
                return err
        }
        o.Value = v
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptURI) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptURI) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ValidationErrorErrors as json.
func (o OptValidationErrorErrors) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        o.Value.Encode(e)
}

// Decode decodes ValidationErrorErrors from json.
func (o *OptValidationErrorErrors) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptValidationErrorErrors to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptValidationErrorErrors) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptValidationErrorErrors) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookDelivery as json.
func (o OptWebhookDelivery) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes WebhookDelivery from json.
func (o *OptWebhookDelivery) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptWebhookDelivery to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptWebhookDelivery) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptWebhookDelivery) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookResponse as json.
func (o OptWebhookResponse) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes WebhookResponse from json.
func (o *OptWebhookResponse) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptWebhookResponse to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptWebhookResponse) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptWebhookResponse) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookTrigger as json.
func (o OptWebhookTrigger) Encode(e *jx.Encoder) {
        if !o.Set {
                return
        }
        e.Str(string(o.Value))
}

// Decode decodes WebhookTrigger from json.
func (o *OptWebhookTrigger) Decode(d *jx.Decoder) error {
        if o == nil {
                return errors.New("invalid: unable to decode OptWebhookTrigger to nil")
        }
        o.Set = true
        if err := o.Value.Decode(d); err != nil {
                return err
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptWebhookTrigger) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptWebhookTrigger) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PageLink) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PageLink) encodeFields(e *jx.Encoder) {
        {
                if s.Self.Set {
                        e.FieldStart("self")
                        s.Self.Encode(e)
                }
        }
        {
                if s.First.Set {
                        e.FieldStart("first")
                        s.First.Encode(e)
                }
        }
        {
                if s.Next.Set {
                        e.FieldStart("next")
                        s.Next.Encode(e)
                }
        }
        {
                if s.Prev.Set {
                        e.FieldStart("prev")
                        s.Prev.Encode(e)
                }
        }
        {
                if s.Last.Set {
                        e.FieldStart("last")
                        s.Last.Encode(e)
                }
        }
}

var jsonFieldsNameOfPageLink = [5]string{
        0: "self",
        1: "first",
        2: "next",
        3: "prev",
        4: "last",
}

// Decode decodes PageLink from json.
func (s *PageLink) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PageLink to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "self":
                        if err := func() error {
                                s.Self.Reset()
                                if err := s.Self.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"self\"")
                        }
                case "first":
                        if err := func() error {
                                s.First.Reset()
                                if err := s.First.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"first\"")
                        }
                case "next":
                        if err := func() error {
                                s.Next.Reset()
                                if err := s.Next.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"next\"")
                        }
                case "prev":
                        if err := func() error {
                                s.Prev.Reset()
                                if err := s.Prev.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"prev\"")
                        }
                case "last":
                        if err := func() error {
                                s.Last.Reset()
                                if err := s.Last.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"last\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PageLink")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PageLink) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PageLink) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBank) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBank) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("account_id")
                e.Str(s.AccountID)
        }
        {
                if s.AccountName.Set {
                        e.FieldStart("account_name")
                        s.AccountName.Encode(e)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                e.FieldStart("target_amount")
                s.TargetAmount.Encode(e)
        }
        {
                if s.Percentage.Set {
                        e.FieldStart("percentage")
                        s.Percentage.Encode(e)
                }
        }
        {
                if s.CurrentAmount.Set {
                        e.FieldStart("current_amount")
                        s.CurrentAmount.Encode(e)
                }
        }
        {
                if s.LeftToSave.Set {
                        e.FieldStart("left_to_save")
                        s.LeftToSave.Encode(e)
                }
        }
        {
                if s.SavePerMonth.Set {
                        e.FieldStart("save_per_month")
                        s.SavePerMonth.Encode(e)
                }
        }
        {
                if s.StartDate.Set {
                        e.FieldStart("start_date")
                        s.StartDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.TargetDate.Set {
                        e.FieldStart("target_date")
                        s.TargetDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupOrder.Set {
                        e.FieldStart("object_group_order")
                        s.ObjectGroupOrder.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfPiggyBank = [22]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "account_id",
        3:  "account_name",
        4:  "name",
        5:  "currency_id",
        6:  "currency_code",
        7:  "currency_symbol",
        8:  "currency_decimal_places",
        9:  "target_amount",
        10: "percentage",
        11: "current_amount",
        12: "left_to_save",
        13: "save_per_month",
        14: "start_date",
        15: "target_date",
        16: "order",
        17: "active",
        18: "notes",
        19: "object_group_id",
        20: "object_group_order",
        21: "object_group_title",
}

// Decode decodes PiggyBank from json.
func (s *PiggyBank) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBank to nil")
        }
        var requiredBitSet [3]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "account_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.AccountID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_id\"")
                        }
                case "account_name":
                        if err := func() error {
                                s.AccountName.Reset()
                                if err := s.AccountName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_name\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "target_amount":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                if err := s.TargetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_amount\"")
                        }
                case "percentage":
                        if err := func() error {
                                s.Percentage.Reset()
                                if err := s.Percentage.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"percentage\"")
                        }
                case "current_amount":
                        if err := func() error {
                                s.CurrentAmount.Reset()
                                if err := s.CurrentAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_amount\"")
                        }
                case "left_to_save":
                        if err := func() error {
                                s.LeftToSave.Reset()
                                if err := s.LeftToSave.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"left_to_save\"")
                        }
                case "save_per_month":
                        if err := func() error {
                                s.SavePerMonth.Reset()
                                if err := s.SavePerMonth.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"save_per_month\"")
                        }
                case "start_date":
                        if err := func() error {
                                s.StartDate.Reset()
                                if err := s.StartDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start_date\"")
                        }
                case "target_date":
                        if err := func() error {
                                s.TargetDate.Reset()
                                if err := s.TargetDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_date\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_order":
                        if err := func() error {
                                s.ObjectGroupOrder.Reset()
                                if err := s.ObjectGroupOrder.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_order\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBank")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [3]uint8{
                0b00010100,
                0b00000010,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBank) {
                                        name = jsonFieldsNameOfPiggyBank[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBank) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBank) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfPiggyBankArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes PiggyBankArray from json.
func (s *PiggyBankArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]PiggyBankRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem PiggyBankRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankArray) {
                                        name = jsonFieldsNameOfPiggyBankArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankEvent) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankEvent) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.Amount.Set {
                        e.FieldStart("amount")
                        s.Amount.Encode(e)
                }
        }
        {
                if s.TransactionJournalID.Set {
                        e.FieldStart("transaction_journal_id")
                        s.TransactionJournalID.Encode(e)
                }
        }
        {
                if s.TransactionGroupID.Set {
                        e.FieldStart("transaction_group_id")
                        s.TransactionGroupID.Encode(e)
                }
        }
}

var jsonFieldsNameOfPiggyBankEvent = [9]string{
        0: "created_at",
        1: "updated_at",
        2: "currency_id",
        3: "currency_code",
        4: "currency_symbol",
        5: "currency_decimal_places",
        6: "amount",
        7: "transaction_journal_id",
        8: "transaction_group_id",
}

// Decode decodes PiggyBankEvent from json.
func (s *PiggyBankEvent) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankEvent to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "amount":
                        if err := func() error {
                                s.Amount.Reset()
                                if err := s.Amount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "transaction_journal_id":
                        if err := func() error {
                                s.TransactionJournalID.Reset()
                                if err := s.TransactionJournalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_journal_id\"")
                        }
                case "transaction_group_id":
                        if err := func() error {
                                s.TransactionGroupID.Reset()
                                if err := s.TransactionGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_group_id\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankEvent")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankEvent) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankEvent) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankEventArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankEventArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfPiggyBankEventArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes PiggyBankEventArray from json.
func (s *PiggyBankEventArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankEventArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]PiggyBankEventRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem PiggyBankEventRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankEventArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankEventArray) {
                                        name = jsonFieldsNameOfPiggyBankEventArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankEventArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankEventArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankEventRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankEventRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfPiggyBankEventRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes PiggyBankEventRead from json.
func (s *PiggyBankEventRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankEventRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankEventRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankEventRead) {
                                        name = jsonFieldsNameOfPiggyBankEventRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankEventRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankEventRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfPiggyBankRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes PiggyBankRead from json.
func (s *PiggyBankRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankRead) {
                                        name = jsonFieldsNameOfPiggyBankRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfPiggyBankSingle = [1]string{
        0: "data",
}

// Decode decodes PiggyBankSingle from json.
func (s *PiggyBankSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankSingle) {
                                        name = jsonFieldsNameOfPiggyBankSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("account_id")
                e.Str(s.AccountID)
        }
        {
                e.FieldStart("target_amount")
                s.TargetAmount.Encode(e)
        }
        {
                if s.CurrentAmount.Set {
                        e.FieldStart("current_amount")
                        s.CurrentAmount.Encode(e)
                }
        }
        {
                if s.StartDate.Set {
                        e.FieldStart("start_date")
                        s.StartDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.TargetDate.Set {
                        e.FieldStart("target_date")
                        s.TargetDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfPiggyBankStore = [11]string{
        0:  "name",
        1:  "account_id",
        2:  "target_amount",
        3:  "current_amount",
        4:  "start_date",
        5:  "target_date",
        6:  "order",
        7:  "active",
        8:  "notes",
        9:  "object_group_id",
        10: "object_group_title",
}

// Decode decodes PiggyBankStore from json.
func (s *PiggyBankStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankStore to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "account_id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.AccountID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_id\"")
                        }
                case "target_amount":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.TargetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_amount\"")
                        }
                case "current_amount":
                        if err := func() error {
                                s.CurrentAmount.Reset()
                                if err := s.CurrentAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_amount\"")
                        }
                case "start_date":
                        if err := func() error {
                                s.StartDate.Reset()
                                if err := s.StartDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start_date\"")
                        }
                case "target_date":
                        if err := func() error {
                                s.TargetDate.Reset()
                                if err := s.TargetDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_date\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000111,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPiggyBankStore) {
                                        name = jsonFieldsNameOfPiggyBankStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PiggyBankUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PiggyBankUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Name.Set {
                        e.FieldStart("name")
                        s.Name.Encode(e)
                }
        }
        {
                if s.AccountID.Set {
                        e.FieldStart("account_id")
                        s.AccountID.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.TargetAmount.Set {
                        e.FieldStart("target_amount")
                        s.TargetAmount.Encode(e)
                }
        }
        {
                if s.CurrentAmount.Set {
                        e.FieldStart("current_amount")
                        s.CurrentAmount.Encode(e)
                }
        }
        {
                if s.StartDate.Set {
                        e.FieldStart("start_date")
                        s.StartDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.TargetDate.Set {
                        e.FieldStart("target_date")
                        s.TargetDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.ObjectGroupID.Set {
                        e.FieldStart("object_group_id")
                        s.ObjectGroupID.Encode(e)
                }
        }
        {
                if s.ObjectGroupTitle.Set {
                        e.FieldStart("object_group_title")
                        s.ObjectGroupTitle.Encode(e)
                }
        }
}

var jsonFieldsNameOfPiggyBankUpdate = [13]string{
        0:  "name",
        1:  "account_id",
        2:  "currency_id",
        3:  "currency_code",
        4:  "target_amount",
        5:  "current_amount",
        6:  "start_date",
        7:  "target_date",
        8:  "order",
        9:  "active",
        10: "notes",
        11: "object_group_id",
        12: "object_group_title",
}

// Decode decodes PiggyBankUpdate from json.
func (s *PiggyBankUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PiggyBankUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "name":
                        if err := func() error {
                                s.Name.Reset()
                                if err := s.Name.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "account_id":
                        if err := func() error {
                                s.AccountID.Reset()
                                if err := s.AccountID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"account_id\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "target_amount":
                        if err := func() error {
                                s.TargetAmount.Reset()
                                if err := s.TargetAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_amount\"")
                        }
                case "current_amount":
                        if err := func() error {
                                s.CurrentAmount.Reset()
                                if err := s.CurrentAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"current_amount\"")
                        }
                case "start_date":
                        if err := func() error {
                                s.StartDate.Reset()
                                if err := s.StartDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start_date\"")
                        }
                case "target_date":
                        if err := func() error {
                                s.TargetDate.Reset()
                                if err := s.TargetDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"target_date\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "object_group_id":
                        if err := func() error {
                                s.ObjectGroupID.Reset()
                                if err := s.ObjectGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_id\"")
                        }
                case "object_group_title":
                        if err := func() error {
                                s.ObjectGroupTitle.Reset()
                                if err := s.ObjectGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"object_group_title\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PiggyBankUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PiggyBankUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PiggyBankUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes PolymorphicProperty as json.
func (s PolymorphicProperty) Encode(e *jx.Encoder) {
        switch s.Type {
        case BoolPolymorphicProperty:
                e.Bool(s.Bool)
        case StringPolymorphicProperty:
                e.Str(s.String)
        case PolymorphicProperty2PolymorphicProperty:
                s.PolymorphicProperty2.Encode(e)
        case StringArrayItemArrayPolymorphicProperty:
                e.ArrStart()
                for _, elem := range s.StringArrayItemArray {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

// Decode decodes PolymorphicProperty from json.
func (s *PolymorphicProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PolymorphicProperty to nil")
        }
        // Sum type type_discriminator.
        switch t := d.Next(); t {
        case jx.Array:
                s.StringArrayItemArray = make([]StringArrayItem, 0)
                if err := d.Arr(func(d *jx.Decoder) error {
                        var elem StringArrayItem
                        if err := elem.Decode(d); err != nil {
                                return err
                        }
                        s.StringArrayItemArray = append(s.StringArrayItemArray, elem)
                        return nil
                }); err != nil {
                        return err
                }
                s.Type = StringArrayItemArrayPolymorphicProperty
        case jx.Bool:
                v, err := d.Bool()
                s.Bool = bool(v)
                if err != nil {
                        return err
                }
                s.Type = BoolPolymorphicProperty
        case jx.Object:
                if err := s.PolymorphicProperty2.Decode(d); err != nil {
                        return err
                }
                s.Type = PolymorphicProperty2PolymorphicProperty
        case jx.String:
                v, err := d.Str()
                s.String = string(v)
                if err != nil {
                        return err
                }
                s.Type = StringPolymorphicProperty
        default:
                return errors.Errorf("unexpected json type %q", t)
        }
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PolymorphicProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PolymorphicProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PolymorphicProperty2) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PolymorphicProperty2) encodeFields(e *jx.Encoder) {
}

var jsonFieldsNameOfPolymorphicProperty2 = [0]string{}

// Decode decodes PolymorphicProperty2 from json.
func (s *PolymorphicProperty2) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PolymorphicProperty2 to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                default:
                        return d.Skip()
                }
        }); err != nil {
                return errors.Wrap(err, "decode PolymorphicProperty2")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PolymorphicProperty2) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PolymorphicProperty2) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Preference) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Preference) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("name")
                e.Str(s.Name)
        }
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfPreference = [4]string{
        0: "created_at",
        1: "updated_at",
        2: "name",
        3: "data",
}

// Decode decodes Preference from json.
func (s *Preference) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Preference to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "name":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Name = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "data":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Preference")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPreference) {
                                        name = jsonFieldsNameOfPreference[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Preference) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Preference) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PreferenceArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PreferenceArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfPreferenceArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes PreferenceArray from json.
func (s *PreferenceArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PreferenceArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]PreferenceRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem PreferenceRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PreferenceArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPreferenceArray) {
                                        name = jsonFieldsNameOfPreferenceArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PreferenceArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PreferenceArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PreferenceRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PreferenceRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfPreferenceRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes PreferenceRead from json.
func (s *PreferenceRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PreferenceRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PreferenceRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPreferenceRead) {
                                        name = jsonFieldsNameOfPreferenceRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PreferenceRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PreferenceRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PreferenceSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PreferenceSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfPreferenceSingle = [1]string{
        0: "data",
}

// Decode decodes PreferenceSingle from json.
func (s *PreferenceSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PreferenceSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PreferenceSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPreferenceSingle) {
                                        name = jsonFieldsNameOfPreferenceSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PreferenceSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PreferenceSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PreferenceUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PreferenceUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfPreferenceUpdate = [1]string{
        0: "data",
}

// Decode decodes PreferenceUpdate from json.
func (s *PreferenceUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode PreferenceUpdate to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode PreferenceUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfPreferenceUpdate) {
                                        name = jsonFieldsNameOfPreferenceUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PreferenceUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PreferenceUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Recurrence) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Recurrence) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.FirstDate.Set {
                        e.FieldStart("first_date")
                        s.FirstDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.LatestDate.Set {
                        e.FieldStart("latest_date")
                        s.LatestDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.RepeatUntil.Set {
                        e.FieldStart("repeat_until")
                        s.RepeatUntil.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.NrOfRepetitions.Set {
                        e.FieldStart("nr_of_repetitions")
                        s.NrOfRepetitions.Encode(e)
                }
        }
        {
                if s.ApplyRules.Set {
                        e.FieldStart("apply_rules")
                        s.ApplyRules.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Repetitions != nil {
                        e.FieldStart("repetitions")
                        e.ArrStart()
                        for _, elem := range s.Repetitions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Transactions != nil {
                        e.FieldStart("transactions")
                        e.ArrStart()
                        for _, elem := range s.Transactions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfRecurrence = [14]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "type",
        3:  "title",
        4:  "description",
        5:  "first_date",
        6:  "latest_date",
        7:  "repeat_until",
        8:  "nr_of_repetitions",
        9:  "apply_rules",
        10: "active",
        11: "notes",
        12: "repetitions",
        13: "transactions",
}

// Decode decodes Recurrence from json.
func (s *Recurrence) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Recurrence to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "first_date":
                        if err := func() error {
                                s.FirstDate.Reset()
                                if err := s.FirstDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"first_date\"")
                        }
                case "latest_date":
                        if err := func() error {
                                s.LatestDate.Reset()
                                if err := s.LatestDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latest_date\"")
                        }
                case "repeat_until":
                        if err := func() error {
                                s.RepeatUntil.Reset()
                                if err := s.RepeatUntil.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_until\"")
                        }
                case "nr_of_repetitions":
                        if err := func() error {
                                s.NrOfRepetitions.Reset()
                                if err := s.NrOfRepetitions.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"nr_of_repetitions\"")
                        }
                case "apply_rules":
                        if err := func() error {
                                s.ApplyRules.Reset()
                                if err := s.ApplyRules.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"apply_rules\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "repetitions":
                        if err := func() error {
                                s.Repetitions = make([]RecurrenceRepetition, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceRepetition
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Repetitions = append(s.Repetitions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repetitions\"")
                        }
                case "transactions":
                        if err := func() error {
                                s.Transactions = make([]RecurrenceTransaction, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceTransaction
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Recurrence")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Recurrence) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Recurrence) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRecurrenceArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes RecurrenceArray from json.
func (s *RecurrenceArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]RecurrenceRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceArray) {
                                        name = jsonFieldsNameOfRecurrenceArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRecurrenceRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes RecurrenceRead from json.
func (s *RecurrenceRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceRead) {
                                        name = jsonFieldsNameOfRecurrenceRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceRepetition) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceRepetition) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("moment")
                e.Str(s.Moment)
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Weekend.Set {
                        e.FieldStart("weekend")
                        s.Weekend.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Occurrences != nil {
                        e.FieldStart("occurrences")
                        e.ArrStart()
                        for _, elem := range s.Occurrences {
                                json.EncodeDateTime(e, elem)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfRecurrenceRepetition = [9]string{
        0: "id",
        1: "created_at",
        2: "updated_at",
        3: "type",
        4: "moment",
        5: "skip",
        6: "weekend",
        7: "description",
        8: "occurrences",
}

// Decode decodes RecurrenceRepetition from json.
func (s *RecurrenceRepetition) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceRepetition to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "moment":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Moment = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"moment\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "weekend":
                        if err := func() error {
                                s.Weekend.Reset()
                                if err := s.Weekend.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"weekend\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "occurrences":
                        if err := func() error {
                                s.Occurrences = make([]time.Time, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem time.Time
                                        v, err := json.DecodeDateTime(d)
                                        elem = v
                                        if err != nil {
                                                return err
                                        }
                                        s.Occurrences = append(s.Occurrences, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"occurrences\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceRepetition")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00011000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceRepetition) {
                                        name = jsonFieldsNameOfRecurrenceRepetition[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceRepetition) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceRepetition) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceRepetitionStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceRepetitionStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("moment")
                e.Str(s.Moment)
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Weekend.Set {
                        e.FieldStart("weekend")
                        s.Weekend.Encode(e)
                }
        }
}

var jsonFieldsNameOfRecurrenceRepetitionStore = [4]string{
        0: "type",
        1: "moment",
        2: "skip",
        3: "weekend",
}

// Decode decodes RecurrenceRepetitionStore from json.
func (s *RecurrenceRepetitionStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceRepetitionStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "moment":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Moment = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"moment\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "weekend":
                        if err := func() error {
                                s.Weekend.Reset()
                                if err := s.Weekend.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"weekend\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceRepetitionStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceRepetitionStore) {
                                        name = jsonFieldsNameOfRecurrenceRepetitionStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceRepetitionStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceRepetitionStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RecurrenceRepetitionType as json.
func (s RecurrenceRepetitionType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes RecurrenceRepetitionType from json.
func (s *RecurrenceRepetitionType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceRepetitionType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch RecurrenceRepetitionType(v) {
        case RecurrenceRepetitionTypeDaily:
                *s = RecurrenceRepetitionTypeDaily
        case RecurrenceRepetitionTypeWeekly:
                *s = RecurrenceRepetitionTypeWeekly
        case RecurrenceRepetitionTypeNdom:
                *s = RecurrenceRepetitionTypeNdom
        case RecurrenceRepetitionTypeMonthly:
                *s = RecurrenceRepetitionTypeMonthly
        case RecurrenceRepetitionTypeYearly:
                *s = RecurrenceRepetitionTypeYearly
        default:
                *s = RecurrenceRepetitionType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RecurrenceRepetitionType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceRepetitionType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceRepetitionUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceRepetitionUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.Moment.Set {
                        e.FieldStart("moment")
                        s.Moment.Encode(e)
                }
        }
        {
                if s.Skip.Set {
                        e.FieldStart("skip")
                        s.Skip.Encode(e)
                }
        }
        {
                if s.Weekend.Set {
                        e.FieldStart("weekend")
                        s.Weekend.Encode(e)
                }
        }
}

var jsonFieldsNameOfRecurrenceRepetitionUpdate = [4]string{
        0: "type",
        1: "moment",
        2: "skip",
        3: "weekend",
}

// Decode decodes RecurrenceRepetitionUpdate from json.
func (s *RecurrenceRepetitionUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceRepetitionUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "moment":
                        if err := func() error {
                                s.Moment.Reset()
                                if err := s.Moment.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"moment\"")
                        }
                case "skip":
                        if err := func() error {
                                s.Skip.Reset()
                                if err := s.Skip.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"skip\"")
                        }
                case "weekend":
                        if err := func() error {
                                s.Weekend.Reset()
                                if err := s.Weekend.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"weekend\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceRepetitionUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceRepetitionUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceRepetitionUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfRecurrenceSingle = [1]string{
        0: "data",
}

// Decode decodes RecurrenceSingle from json.
func (s *RecurrenceSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceSingle) {
                                        name = jsonFieldsNameOfRecurrenceSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                e.FieldStart("first_date")
                json.EncodeDate(e, s.FirstDate)
        }
        {
                e.FieldStart("repeat_until")
                s.RepeatUntil.Encode(e, json.EncodeDate)
        }
        {
                if s.NrOfRepetitions.Set {
                        e.FieldStart("nr_of_repetitions")
                        s.NrOfRepetitions.Encode(e)
                }
        }
        {
                if s.ApplyRules.Set {
                        e.FieldStart("apply_rules")
                        s.ApplyRules.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                e.FieldStart("repetitions")
                e.ArrStart()
                for _, elem := range s.Repetitions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("transactions")
                e.ArrStart()
                for _, elem := range s.Transactions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

var jsonFieldsNameOfRecurrenceStore = [11]string{
        0:  "type",
        1:  "title",
        2:  "description",
        3:  "first_date",
        4:  "repeat_until",
        5:  "nr_of_repetitions",
        6:  "apply_rules",
        7:  "active",
        8:  "notes",
        9:  "repetitions",
        10: "transactions",
}

// Decode decodes RecurrenceStore from json.
func (s *RecurrenceStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceStore to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "first_date":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := json.DecodeDate(d)
                                s.FirstDate = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"first_date\"")
                        }
                case "repeat_until":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                if err := s.RepeatUntil.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_until\"")
                        }
                case "nr_of_repetitions":
                        if err := func() error {
                                s.NrOfRepetitions.Reset()
                                if err := s.NrOfRepetitions.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"nr_of_repetitions\"")
                        }
                case "apply_rules":
                        if err := func() error {
                                s.ApplyRules.Reset()
                                if err := s.ApplyRules.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"apply_rules\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "repetitions":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                s.Repetitions = make([]RecurrenceRepetitionStore, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceRepetitionStore
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Repetitions = append(s.Repetitions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repetitions\"")
                        }
                case "transactions":
                        requiredBitSet[1] |= 1 << 2
                        if err := func() error {
                                s.Transactions = make([]RecurrenceTransactionStore, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceTransactionStore
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00011011,
                0b00000110,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceStore) {
                                        name = jsonFieldsNameOfRecurrenceStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceTransaction) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceTransaction) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyCode.Set {
                        e.FieldStart("foreign_currency_code")
                        s.ForeignCurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignCurrencySymbol.Set {
                        e.FieldStart("foreign_currency_symbol")
                        s.ForeignCurrencySymbol.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyDecimalPlaces.Set {
                        e.FieldStart("foreign_currency_decimal_places")
                        s.ForeignCurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.BudgetName.Set {
                        e.FieldStart("budget_name")
                        s.BudgetName.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                if s.CategoryName.Set {
                        e.FieldStart("category_name")
                        s.CategoryName.Encode(e)
                }
        }
        {
                if s.SourceID.Set {
                        e.FieldStart("source_id")
                        s.SourceID.Encode(e)
                }
        }
        {
                if s.SourceName.Set {
                        e.FieldStart("source_name")
                        s.SourceName.Encode(e)
                }
        }
        {
                if s.SourceIban.Set {
                        e.FieldStart("source_iban")
                        s.SourceIban.Encode(e)
                }
        }
        {
                if s.SourceType.Set {
                        e.FieldStart("source_type")
                        s.SourceType.Encode(e)
                }
        }
        {
                if s.DestinationID.Set {
                        e.FieldStart("destination_id")
                        s.DestinationID.Encode(e)
                }
        }
        {
                if s.DestinationName.Set {
                        e.FieldStart("destination_name")
                        s.DestinationName.Encode(e)
                }
        }
        {
                if s.DestinationIban.Set {
                        e.FieldStart("destination_iban")
                        s.DestinationIban.Encode(e)
                }
        }
        {
                if s.DestinationType.Set {
                        e.FieldStart("destination_type")
                        s.DestinationType.Encode(e)
                }
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.PiggyBankID.Set {
                        e.FieldStart("piggy_bank_id")
                        s.PiggyBankID.Encode(e)
                }
        }
        {
                if s.PiggyBankName.Set {
                        e.FieldStart("piggy_bank_name")
                        s.PiggyBankName.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
        {
                if s.BillName.Set {
                        e.FieldStart("bill_name")
                        s.BillName.Encode(e)
                }
        }
}

var jsonFieldsNameOfRecurrenceTransaction = [29]string{
        0:  "id",
        1:  "description",
        2:  "amount",
        3:  "foreign_amount",
        4:  "currency_id",
        5:  "currency_code",
        6:  "currency_symbol",
        7:  "currency_decimal_places",
        8:  "foreign_currency_id",
        9:  "foreign_currency_code",
        10: "foreign_currency_symbol",
        11: "foreign_currency_decimal_places",
        12: "budget_id",
        13: "budget_name",
        14: "category_id",
        15: "category_name",
        16: "source_id",
        17: "source_name",
        18: "source_iban",
        19: "source_type",
        20: "destination_id",
        21: "destination_name",
        22: "destination_iban",
        23: "destination_type",
        24: "tags",
        25: "piggy_bank_id",
        26: "piggy_bank_name",
        27: "bill_id",
        28: "bill_name",
}

// Decode decodes RecurrenceTransaction from json.
func (s *RecurrenceTransaction) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceTransaction to nil")
        }
        var requiredBitSet [4]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "description":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "amount":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "foreign_currency_code":
                        if err := func() error {
                                s.ForeignCurrencyCode.Reset()
                                if err := s.ForeignCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_code\"")
                        }
                case "foreign_currency_symbol":
                        if err := func() error {
                                s.ForeignCurrencySymbol.Reset()
                                if err := s.ForeignCurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_symbol\"")
                        }
                case "foreign_currency_decimal_places":
                        if err := func() error {
                                s.ForeignCurrencyDecimalPlaces.Reset()
                                if err := s.ForeignCurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_decimal_places\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "budget_name":
                        if err := func() error {
                                s.BudgetName.Reset()
                                if err := s.BudgetName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_name\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "category_name":
                        if err := func() error {
                                s.CategoryName.Reset()
                                if err := s.CategoryName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_name\"")
                        }
                case "source_id":
                        if err := func() error {
                                s.SourceID.Reset()
                                if err := s.SourceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "source_name":
                        if err := func() error {
                                s.SourceName.Reset()
                                if err := s.SourceName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_name\"")
                        }
                case "source_iban":
                        if err := func() error {
                                s.SourceIban.Reset()
                                if err := s.SourceIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_iban\"")
                        }
                case "source_type":
                        if err := func() error {
                                s.SourceType.Reset()
                                if err := s.SourceType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_type\"")
                        }
                case "destination_id":
                        if err := func() error {
                                s.DestinationID.Reset()
                                if err := s.DestinationID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "destination_name":
                        if err := func() error {
                                s.DestinationName.Reset()
                                if err := s.DestinationName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_name\"")
                        }
                case "destination_iban":
                        if err := func() error {
                                s.DestinationIban.Reset()
                                if err := s.DestinationIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_iban\"")
                        }
                case "destination_type":
                        if err := func() error {
                                s.DestinationType.Reset()
                                if err := s.DestinationType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_type\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "piggy_bank_id":
                        if err := func() error {
                                s.PiggyBankID.Reset()
                                if err := s.PiggyBankID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_id\"")
                        }
                case "piggy_bank_name":
                        if err := func() error {
                                s.PiggyBankName.Reset()
                                if err := s.PiggyBankName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_name\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                case "bill_name":
                        if err := func() error {
                                s.BillName.Reset()
                                if err := s.BillName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_name\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceTransaction")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [4]uint8{
                0b00000110,
                0b00000000,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceTransaction) {
                                        name = jsonFieldsNameOfRecurrenceTransaction[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceTransaction) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceTransaction) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceTransactionStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceTransactionStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyCode.Set {
                        e.FieldStart("foreign_currency_code")
                        s.ForeignCurrencyCode.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                e.FieldStart("source_id")
                e.Str(s.SourceID)
        }
        {
                e.FieldStart("destination_id")
                e.Str(s.DestinationID)
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.PiggyBankID.Set {
                        e.FieldStart("piggy_bank_id")
                        s.PiggyBankID.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
}

var jsonFieldsNameOfRecurrenceTransactionStore = [14]string{
        0:  "description",
        1:  "amount",
        2:  "foreign_amount",
        3:  "currency_id",
        4:  "currency_code",
        5:  "foreign_currency_id",
        6:  "foreign_currency_code",
        7:  "budget_id",
        8:  "category_id",
        9:  "source_id",
        10: "destination_id",
        11: "tags",
        12: "piggy_bank_id",
        13: "bill_id",
}

// Decode decodes RecurrenceTransactionStore from json.
func (s *RecurrenceTransactionStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceTransactionStore to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "description":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "amount":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "foreign_currency_code":
                        if err := func() error {
                                s.ForeignCurrencyCode.Reset()
                                if err := s.ForeignCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_code\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "source_id":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.SourceID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "destination_id":
                        requiredBitSet[1] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.DestinationID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "piggy_bank_id":
                        if err := func() error {
                                s.PiggyBankID.Reset()
                                if err := s.PiggyBankID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_id\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceTransactionStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000011,
                0b00000110,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceTransactionStore) {
                                        name = jsonFieldsNameOfRecurrenceTransactionStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceTransactionStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceTransactionStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RecurrenceTransactionType as json.
func (s RecurrenceTransactionType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes RecurrenceTransactionType from json.
func (s *RecurrenceTransactionType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceTransactionType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch RecurrenceTransactionType(v) {
        case RecurrenceTransactionTypeWithdrawal:
                *s = RecurrenceTransactionTypeWithdrawal
        case RecurrenceTransactionTypeTransfer:
                *s = RecurrenceTransactionTypeTransfer
        case RecurrenceTransactionTypeDeposit:
                *s = RecurrenceTransactionTypeDeposit
        default:
                *s = RecurrenceTransactionType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RecurrenceTransactionType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceTransactionType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceTransactionUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceTransactionUpdate) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Amount.Set {
                        e.FieldStart("amount")
                        s.Amount.Encode(e)
                }
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                if s.SourceID.Set {
                        e.FieldStart("source_id")
                        s.SourceID.Encode(e)
                }
        }
        {
                if s.DestinationID.Set {
                        e.FieldStart("destination_id")
                        s.DestinationID.Encode(e)
                }
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.PiggyBankID.Set {
                        e.FieldStart("piggy_bank_id")
                        s.PiggyBankID.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
}

var jsonFieldsNameOfRecurrenceTransactionUpdate = [14]string{
        0:  "id",
        1:  "description",
        2:  "amount",
        3:  "foreign_amount",
        4:  "currency_id",
        5:  "currency_code",
        6:  "foreign_currency_id",
        7:  "budget_id",
        8:  "category_id",
        9:  "source_id",
        10: "destination_id",
        11: "tags",
        12: "piggy_bank_id",
        13: "bill_id",
}

// Decode decodes RecurrenceTransactionUpdate from json.
func (s *RecurrenceTransactionUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceTransactionUpdate to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "amount":
                        if err := func() error {
                                s.Amount.Reset()
                                if err := s.Amount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "source_id":
                        if err := func() error {
                                s.SourceID.Reset()
                                if err := s.SourceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "destination_id":
                        if err := func() error {
                                s.DestinationID.Reset()
                                if err := s.DestinationID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "piggy_bank_id":
                        if err := func() error {
                                s.PiggyBankID.Reset()
                                if err := s.PiggyBankID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_id\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceTransactionUpdate")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00000001,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRecurrenceTransactionUpdate) {
                                        name = jsonFieldsNameOfRecurrenceTransactionUpdate[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceTransactionUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceTransactionUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RecurrenceUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RecurrenceUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.FirstDate.Set {
                        e.FieldStart("first_date")
                        s.FirstDate.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.RepeatUntil.Set {
                        e.FieldStart("repeat_until")
                        s.RepeatUntil.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.NrOfRepetitions.Set {
                        e.FieldStart("nr_of_repetitions")
                        s.NrOfRepetitions.Encode(e)
                }
        }
        {
                if s.ApplyRules.Set {
                        e.FieldStart("apply_rules")
                        s.ApplyRules.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Repetitions != nil {
                        e.FieldStart("repetitions")
                        e.ArrStart()
                        for _, elem := range s.Repetitions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Transactions != nil {
                        e.FieldStart("transactions")
                        e.ArrStart()
                        for _, elem := range s.Transactions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfRecurrenceUpdate = [10]string{
        0: "title",
        1: "description",
        2: "first_date",
        3: "repeat_until",
        4: "nr_of_repetitions",
        5: "apply_rules",
        6: "active",
        7: "notes",
        8: "repetitions",
        9: "transactions",
}

// Decode decodes RecurrenceUpdate from json.
func (s *RecurrenceUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RecurrenceUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "first_date":
                        if err := func() error {
                                s.FirstDate.Reset()
                                if err := s.FirstDate.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"first_date\"")
                        }
                case "repeat_until":
                        if err := func() error {
                                s.RepeatUntil.Reset()
                                if err := s.RepeatUntil.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repeat_until\"")
                        }
                case "nr_of_repetitions":
                        if err := func() error {
                                s.NrOfRepetitions.Reset()
                                if err := s.NrOfRepetitions.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"nr_of_repetitions\"")
                        }
                case "apply_rules":
                        if err := func() error {
                                s.ApplyRules.Reset()
                                if err := s.ApplyRules.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"apply_rules\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "repetitions":
                        if err := func() error {
                                s.Repetitions = make([]RecurrenceRepetitionUpdate, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceRepetitionUpdate
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Repetitions = append(s.Repetitions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"repetitions\"")
                        }
                case "transactions":
                        if err := func() error {
                                s.Transactions = make([]RecurrenceTransactionUpdate, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RecurrenceTransactionUpdate
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RecurrenceUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RecurrenceUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecurrenceUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Rule) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Rule) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                e.FieldStart("rule_group_id")
                e.Str(s.RuleGroupID)
        }
        {
                if s.RuleGroupTitle.Set {
                        e.FieldStart("rule_group_title")
                        s.RuleGroupTitle.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                e.FieldStart("trigger")
                s.Trigger.Encode(e)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Strict.Set {
                        e.FieldStart("strict")
                        s.Strict.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
        {
                e.FieldStart("triggers")
                e.ArrStart()
                for _, elem := range s.Triggers {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("actions")
                e.ArrStart()
                for _, elem := range s.Actions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

var jsonFieldsNameOfRule = [13]string{
        0:  "created_at",
        1:  "updated_at",
        2:  "title",
        3:  "description",
        4:  "rule_group_id",
        5:  "rule_group_title",
        6:  "order",
        7:  "trigger",
        8:  "active",
        9:  "strict",
        10: "stop_processing",
        11: "triggers",
        12: "actions",
}

// Decode decodes Rule from json.
func (s *Rule) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Rule to nil")
        }
        var requiredBitSet [2]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "rule_group_id":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.RuleGroupID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rule_group_id\"")
                        }
                case "rule_group_title":
                        if err := func() error {
                                s.RuleGroupTitle.Reset()
                                if err := s.RuleGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rule_group_title\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "trigger":
                        requiredBitSet[0] |= 1 << 7
                        if err := func() error {
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "strict":
                        if err := func() error {
                                s.Strict.Reset()
                                if err := s.Strict.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"strict\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                case "triggers":
                        requiredBitSet[1] |= 1 << 3
                        if err := func() error {
                                s.Triggers = make([]RuleTrigger, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleTrigger
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Triggers = append(s.Triggers, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"triggers\"")
                        }
                case "actions":
                        requiredBitSet[1] |= 1 << 4
                        if err := func() error {
                                s.Actions = make([]RuleAction, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleAction
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Actions = append(s.Actions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"actions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Rule")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b10010100,
                0b00011000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRule) {
                                        name = jsonFieldsNameOfRule[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Rule) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Rule) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleAction) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleAction) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("value")
                s.Value.Encode(e)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleAction = [8]string{
        0: "id",
        1: "created_at",
        2: "updated_at",
        3: "type",
        4: "value",
        5: "order",
        6: "active",
        7: "stop_processing",
}

// Decode decodes RuleAction from json.
func (s *RuleAction) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleAction to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleAction")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00011000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleAction) {
                                        name = jsonFieldsNameOfRuleAction[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleAction) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleAction) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleActionKeyword as json.
func (s RuleActionKeyword) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes RuleActionKeyword from json.
func (s *RuleActionKeyword) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleActionKeyword to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch RuleActionKeyword(v) {
        case RuleActionKeywordUserAction:
                *s = RuleActionKeywordUserAction
        case RuleActionKeywordSetCategory:
                *s = RuleActionKeywordSetCategory
        case RuleActionKeywordClearCategory:
                *s = RuleActionKeywordClearCategory
        case RuleActionKeywordSetBudget:
                *s = RuleActionKeywordSetBudget
        case RuleActionKeywordClearBudget:
                *s = RuleActionKeywordClearBudget
        case RuleActionKeywordAddTag:
                *s = RuleActionKeywordAddTag
        case RuleActionKeywordRemoveTag:
                *s = RuleActionKeywordRemoveTag
        case RuleActionKeywordRemoveAllTags:
                *s = RuleActionKeywordRemoveAllTags
        case RuleActionKeywordSetDescription:
                *s = RuleActionKeywordSetDescription
        case RuleActionKeywordAppendDescription:
                *s = RuleActionKeywordAppendDescription
        case RuleActionKeywordPrependDescription:
                *s = RuleActionKeywordPrependDescription
        case RuleActionKeywordSetSourceAccount:
                *s = RuleActionKeywordSetSourceAccount
        case RuleActionKeywordSetDestinationAccount:
                *s = RuleActionKeywordSetDestinationAccount
        case RuleActionKeywordSetNotes:
                *s = RuleActionKeywordSetNotes
        case RuleActionKeywordAppendNotes:
                *s = RuleActionKeywordAppendNotes
        case RuleActionKeywordPrependNotes:
                *s = RuleActionKeywordPrependNotes
        case RuleActionKeywordClearNotes:
                *s = RuleActionKeywordClearNotes
        case RuleActionKeywordLinkToBill:
                *s = RuleActionKeywordLinkToBill
        case RuleActionKeywordConvertWithdrawal:
                *s = RuleActionKeywordConvertWithdrawal
        case RuleActionKeywordConvertDeposit:
                *s = RuleActionKeywordConvertDeposit
        case RuleActionKeywordConvertTransfer:
                *s = RuleActionKeywordConvertTransfer
        case RuleActionKeywordDeleteTransaction:
                *s = RuleActionKeywordDeleteTransaction
        default:
                *s = RuleActionKeyword(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RuleActionKeyword) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleActionKeyword) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleActionStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleActionStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("value")
                s.Value.Encode(e)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleActionStore = [5]string{
        0: "type",
        1: "value",
        2: "order",
        3: "active",
        4: "stop_processing",
}

// Decode decodes RuleActionStore from json.
func (s *RuleActionStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleActionStore to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleActionStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleActionStore) {
                                        name = jsonFieldsNameOfRuleActionStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleActionStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleActionStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleActionUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleActionUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.Value.Set {
                        e.FieldStart("value")
                        s.Value.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleActionUpdate = [5]string{
        0: "type",
        1: "value",
        2: "order",
        3: "active",
        4: "stop_processing",
}

// Decode decodes RuleActionUpdate from json.
func (s *RuleActionUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleActionUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        if err := func() error {
                                s.Value.Reset()
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleActionUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleActionUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleActionUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRuleArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes RuleArray from json.
func (s *RuleArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]RuleRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleArray) {
                                        name = jsonFieldsNameOfRuleArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroup) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroup) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleGroup = [6]string{
        0: "created_at",
        1: "updated_at",
        2: "title",
        3: "description",
        4: "order",
        5: "active",
}

// Decode decodes RuleGroup from json.
func (s *RuleGroup) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroup to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroup")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleGroup) {
                                        name = jsonFieldsNameOfRuleGroup[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroup) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroup) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroupArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroupArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRuleGroupArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes RuleGroupArray from json.
func (s *RuleGroupArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroupArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]RuleGroupRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleGroupRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroupArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleGroupArray) {
                                        name = jsonFieldsNameOfRuleGroupArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroupArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroupArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroupRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroupRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRuleGroupRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes RuleGroupRead from json.
func (s *RuleGroupRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroupRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroupRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleGroupRead) {
                                        name = jsonFieldsNameOfRuleGroupRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroupRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroupRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroupSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroupSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfRuleGroupSingle = [1]string{
        0: "data",
}

// Decode decodes RuleGroupSingle from json.
func (s *RuleGroupSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroupSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroupSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleGroupSingle) {
                                        name = jsonFieldsNameOfRuleGroupSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroupSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroupSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroupStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroupStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleGroupStore = [4]string{
        0: "title",
        1: "description",
        2: "order",
        3: "active",
}

// Decode decodes RuleGroupStore from json.
func (s *RuleGroupStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroupStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroupStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleGroupStore) {
                                        name = jsonFieldsNameOfRuleGroupStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroupStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroupStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleGroupUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleGroupUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleGroupUpdate = [4]string{
        0: "title",
        1: "description",
        2: "order",
        3: "active",
}

// Decode decodes RuleGroupUpdate from json.
func (s *RuleGroupUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleGroupUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleGroupUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleGroupUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleGroupUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfRuleRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes RuleRead from json.
func (s *RuleRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleRead) {
                                        name = jsonFieldsNameOfRuleRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfRuleSingle = [1]string{
        0: "data",
}

// Decode decodes RuleSingle from json.
func (s *RuleSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleSingle) {
                                        name = jsonFieldsNameOfRuleSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                e.FieldStart("rule_group_id")
                e.Str(s.RuleGroupID)
        }
        {
                if s.RuleGroupTitle.Set {
                        e.FieldStart("rule_group_title")
                        s.RuleGroupTitle.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                e.FieldStart("trigger")
                s.Trigger.Encode(e)
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Strict.Set {
                        e.FieldStart("strict")
                        s.Strict.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
        {
                e.FieldStart("triggers")
                e.ArrStart()
                for _, elem := range s.Triggers {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("actions")
                e.ArrStart()
                for _, elem := range s.Actions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

var jsonFieldsNameOfRuleStore = [11]string{
        0:  "title",
        1:  "description",
        2:  "rule_group_id",
        3:  "rule_group_title",
        4:  "order",
        5:  "trigger",
        6:  "active",
        7:  "strict",
        8:  "stop_processing",
        9:  "triggers",
        10: "actions",
}

// Decode decodes RuleStore from json.
func (s *RuleStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleStore to nil")
        }
        var requiredBitSet [2]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "rule_group_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.RuleGroupID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rule_group_id\"")
                        }
                case "rule_group_title":
                        if err := func() error {
                                s.RuleGroupTitle.Reset()
                                if err := s.RuleGroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rule_group_title\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "trigger":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "strict":
                        if err := func() error {
                                s.Strict.Reset()
                                if err := s.Strict.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"strict\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                case "triggers":
                        requiredBitSet[1] |= 1 << 1
                        if err := func() error {
                                s.Triggers = make([]RuleTriggerStore, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleTriggerStore
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Triggers = append(s.Triggers, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"triggers\"")
                        }
                case "actions":
                        requiredBitSet[1] |= 1 << 2
                        if err := func() error {
                                s.Actions = make([]RuleActionStore, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleActionStore
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Actions = append(s.Actions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"actions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b00100101,
                0b00000110,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleStore) {
                                        name = jsonFieldsNameOfRuleStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleTrigger) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleTrigger) encodeFields(e *jx.Encoder) {
        {
                if s.ID.Set {
                        e.FieldStart("id")
                        s.ID.Encode(e)
                }
        }
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("value")
                e.Str(s.Value)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleTrigger = [8]string{
        0: "id",
        1: "created_at",
        2: "updated_at",
        3: "type",
        4: "value",
        5: "order",
        6: "active",
        7: "stop_processing",
}

// Decode decodes RuleTrigger from json.
func (s *RuleTrigger) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleTrigger to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "id":
                        if err := func() error {
                                s.ID.Reset()
                                if err := s.ID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.Value = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleTrigger")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00011000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleTrigger) {
                                        name = jsonFieldsNameOfRuleTrigger[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleTrigger) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleTrigger) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleTriggerKeyword as json.
func (s RuleTriggerKeyword) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes RuleTriggerKeyword from json.
func (s *RuleTriggerKeyword) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleTriggerKeyword to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch RuleTriggerKeyword(v) {
        case RuleTriggerKeywordFromAccountStarts:
                *s = RuleTriggerKeywordFromAccountStarts
        case RuleTriggerKeywordFromAccountEnds:
                *s = RuleTriggerKeywordFromAccountEnds
        case RuleTriggerKeywordFromAccountIs:
                *s = RuleTriggerKeywordFromAccountIs
        case RuleTriggerKeywordFromAccountContains:
                *s = RuleTriggerKeywordFromAccountContains
        case RuleTriggerKeywordToAccountStarts:
                *s = RuleTriggerKeywordToAccountStarts
        case RuleTriggerKeywordToAccountEnds:
                *s = RuleTriggerKeywordToAccountEnds
        case RuleTriggerKeywordToAccountIs:
                *s = RuleTriggerKeywordToAccountIs
        case RuleTriggerKeywordToAccountContains:
                *s = RuleTriggerKeywordToAccountContains
        case RuleTriggerKeywordAmountLess:
                *s = RuleTriggerKeywordAmountLess
        case RuleTriggerKeywordAmountExactly:
                *s = RuleTriggerKeywordAmountExactly
        case RuleTriggerKeywordAmountMore:
                *s = RuleTriggerKeywordAmountMore
        case RuleTriggerKeywordDescriptionStarts:
                *s = RuleTriggerKeywordDescriptionStarts
        case RuleTriggerKeywordDescriptionEnds:
                *s = RuleTriggerKeywordDescriptionEnds
        case RuleTriggerKeywordDescriptionContains:
                *s = RuleTriggerKeywordDescriptionContains
        case RuleTriggerKeywordDescriptionIs:
                *s = RuleTriggerKeywordDescriptionIs
        case RuleTriggerKeywordTransactionType:
                *s = RuleTriggerKeywordTransactionType
        case RuleTriggerKeywordCategoryIs:
                *s = RuleTriggerKeywordCategoryIs
        case RuleTriggerKeywordBudgetIs:
                *s = RuleTriggerKeywordBudgetIs
        case RuleTriggerKeywordTagIs:
                *s = RuleTriggerKeywordTagIs
        case RuleTriggerKeywordCurrencyIs:
                *s = RuleTriggerKeywordCurrencyIs
        case RuleTriggerKeywordHasAttachments:
                *s = RuleTriggerKeywordHasAttachments
        case RuleTriggerKeywordHasNoCategory:
                *s = RuleTriggerKeywordHasNoCategory
        case RuleTriggerKeywordHasAnyCategory:
                *s = RuleTriggerKeywordHasAnyCategory
        case RuleTriggerKeywordHasNoBudget:
                *s = RuleTriggerKeywordHasNoBudget
        case RuleTriggerKeywordHasAnyBudget:
                *s = RuleTriggerKeywordHasAnyBudget
        case RuleTriggerKeywordHasNoTag:
                *s = RuleTriggerKeywordHasNoTag
        case RuleTriggerKeywordHasAnyTag:
                *s = RuleTriggerKeywordHasAnyTag
        case RuleTriggerKeywordNotesContains:
                *s = RuleTriggerKeywordNotesContains
        case RuleTriggerKeywordNotesStart:
                *s = RuleTriggerKeywordNotesStart
        case RuleTriggerKeywordNotesEnd:
                *s = RuleTriggerKeywordNotesEnd
        case RuleTriggerKeywordNotesAre:
                *s = RuleTriggerKeywordNotesAre
        case RuleTriggerKeywordNoNotes:
                *s = RuleTriggerKeywordNoNotes
        case RuleTriggerKeywordAnyNotes:
                *s = RuleTriggerKeywordAnyNotes
        case RuleTriggerKeywordSourceAccountIs:
                *s = RuleTriggerKeywordSourceAccountIs
        case RuleTriggerKeywordDestinationAccountIs:
                *s = RuleTriggerKeywordDestinationAccountIs
        case RuleTriggerKeywordSourceAccountStarts:
                *s = RuleTriggerKeywordSourceAccountStarts
        default:
                *s = RuleTriggerKeyword(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RuleTriggerKeyword) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleTriggerKeyword) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleTriggerStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleTriggerStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("value")
                e.Str(s.Value)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleTriggerStore = [5]string{
        0: "type",
        1: "value",
        2: "order",
        3: "active",
        4: "stop_processing",
}

// Decode decodes RuleTriggerStore from json.
func (s *RuleTriggerStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleTriggerStore to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Value = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleTriggerStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfRuleTriggerStore) {
                                        name = jsonFieldsNameOfRuleTriggerStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleTriggerStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleTriggerStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes RuleTriggerType as json.
func (s RuleTriggerType) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes RuleTriggerType from json.
func (s *RuleTriggerType) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleTriggerType to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch RuleTriggerType(v) {
        case RuleTriggerTypeStoreJournal:
                *s = RuleTriggerTypeStoreJournal
        case RuleTriggerTypeUpdateJournal:
                *s = RuleTriggerTypeUpdateJournal
        default:
                *s = RuleTriggerType(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RuleTriggerType) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleTriggerType) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleTriggerUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleTriggerUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.Value.Set {
                        e.FieldStart("value")
                        s.Value.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
}

var jsonFieldsNameOfRuleTriggerUpdate = [5]string{
        0: "type",
        1: "value",
        2: "order",
        3: "active",
        4: "stop_processing",
}

// Decode decodes RuleTriggerUpdate from json.
func (s *RuleTriggerUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleTriggerUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "value":
                        if err := func() error {
                                s.Value.Reset()
                                if err := s.Value.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"value\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleTriggerUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleTriggerUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleTriggerUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RuleUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RuleUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.RuleGroupID.Set {
                        e.FieldStart("rule_group_id")
                        s.RuleGroupID.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.Trigger.Set {
                        e.FieldStart("trigger")
                        s.Trigger.Encode(e)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Strict.Set {
                        e.FieldStart("strict")
                        s.Strict.Encode(e)
                }
        }
        {
                if s.StopProcessing.Set {
                        e.FieldStart("stop_processing")
                        s.StopProcessing.Encode(e)
                }
        }
        {
                if s.Triggers != nil {
                        e.FieldStart("triggers")
                        e.ArrStart()
                        for _, elem := range s.Triggers {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Actions != nil {
                        e.FieldStart("actions")
                        e.ArrStart()
                        for _, elem := range s.Actions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfRuleUpdate = [10]string{
        0: "title",
        1: "description",
        2: "rule_group_id",
        3: "order",
        4: "trigger",
        5: "active",
        6: "strict",
        7: "stop_processing",
        8: "triggers",
        9: "actions",
}

// Decode decodes RuleUpdate from json.
func (s *RuleUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode RuleUpdate to nil")
        }
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "rule_group_id":
                        if err := func() error {
                                s.RuleGroupID.Reset()
                                if err := s.RuleGroupID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"rule_group_id\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "trigger":
                        if err := func() error {
                                s.Trigger.Reset()
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "strict":
                        if err := func() error {
                                s.Strict.Reset()
                                if err := s.Strict.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"strict\"")
                        }
                case "stop_processing":
                        if err := func() error {
                                s.StopProcessing.Reset()
                                if err := s.StopProcessing.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"stop_processing\"")
                        }
                case "triggers":
                        if err := func() error {
                                s.Triggers = make([]RuleTriggerUpdate, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleTriggerUpdate
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Triggers = append(s.Triggers, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"triggers\"")
                        }
                case "actions":
                        if err := func() error {
                                s.Actions = make([]RuleActionUpdate, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem RuleActionUpdate
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Actions = append(s.Actions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"actions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode RuleUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RuleUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RuleUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes ShortAccountTypeProperty as json.
func (s ShortAccountTypeProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes ShortAccountTypeProperty from json.
func (s *ShortAccountTypeProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ShortAccountTypeProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch ShortAccountTypeProperty(v) {
        case ShortAccountTypePropertyAsset:
                *s = ShortAccountTypePropertyAsset
        case ShortAccountTypePropertyExpense:
                *s = ShortAccountTypePropertyExpense
        case ShortAccountTypePropertyImport:
                *s = ShortAccountTypePropertyImport
        case ShortAccountTypePropertyRevenue:
                *s = ShortAccountTypePropertyRevenue
        case ShortAccountTypePropertyCash:
                *s = ShortAccountTypePropertyCash
        case ShortAccountTypePropertyLiability:
                *s = ShortAccountTypePropertyLiability
        case ShortAccountTypePropertyLiabilities:
                *s = ShortAccountTypePropertyLiabilities
        case ShortAccountTypePropertyInitialBalance:
                *s = ShortAccountTypePropertyInitialBalance
        case ShortAccountTypePropertyReconciliation:
                *s = ShortAccountTypePropertyReconciliation
        default:
                *s = ShortAccountTypeProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ShortAccountTypeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ShortAccountTypeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes StringArrayItem as json.
func (s StringArrayItem) Encode(e *jx.Encoder) {
        unwrapped := string(s)

        e.Str(unwrapped)
}

// Decode decodes StringArrayItem from json.
func (s *StringArrayItem) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode StringArrayItem to nil")
        }
        var unwrapped string
        if err := func() error {
                v, err := d.Str()
                unwrapped = string(v)
                if err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                return errors.Wrap(err, "alias")
        }
        *s = StringArrayItem(unwrapped)
        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s StringArrayItem) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StringArrayItem) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SystemInfo) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SystemInfo) encodeFields(e *jx.Encoder) {
        {
                if s.Data.Set {
                        e.FieldStart("data")
                        s.Data.Encode(e)
                }
        }
}

var jsonFieldsNameOfSystemInfo = [1]string{
        0: "data",
}

// Decode decodes SystemInfo from json.
func (s *SystemInfo) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode SystemInfo to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        if err := func() error {
                                s.Data.Reset()
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode SystemInfo")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SystemInfo) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SystemInfo) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SystemInfoData) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SystemInfoData) encodeFields(e *jx.Encoder) {
        {
                if s.Version.Set {
                        e.FieldStart("version")
                        s.Version.Encode(e)
                }
        }
        {
                if s.APIVersion.Set {
                        e.FieldStart("api_version")
                        s.APIVersion.Encode(e)
                }
        }
        {
                if s.PhpVersion.Set {
                        e.FieldStart("php_version")
                        s.PhpVersion.Encode(e)
                }
        }
        {
                if s.Os.Set {
                        e.FieldStart("os")
                        s.Os.Encode(e)
                }
        }
        {
                if s.Driver.Set {
                        e.FieldStart("driver")
                        s.Driver.Encode(e)
                }
        }
}

var jsonFieldsNameOfSystemInfoData = [5]string{
        0: "version",
        1: "api_version",
        2: "php_version",
        3: "os",
        4: "driver",
}

// Decode decodes SystemInfoData from json.
func (s *SystemInfoData) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode SystemInfoData to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "version":
                        if err := func() error {
                                s.Version.Reset()
                                if err := s.Version.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"version\"")
                        }
                case "api_version":
                        if err := func() error {
                                s.APIVersion.Reset()
                                if err := s.APIVersion.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"api_version\"")
                        }
                case "php_version":
                        if err := func() error {
                                s.PhpVersion.Reset()
                                if err := s.PhpVersion.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"php_version\"")
                        }
                case "os":
                        if err := func() error {
                                s.Os.Reset()
                                if err := s.Os.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"os\"")
                        }
                case "driver":
                        if err := func() error {
                                s.Driver.Reset()
                                if err := s.Driver.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"driver\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode SystemInfoData")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SystemInfoData) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SystemInfoData) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTagArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes TagArray from json.
func (s *TagArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]TagRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TagRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTagArray) {
                                        name = jsonFieldsNameOfTagArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagModel) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagModel) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("tag")
                e.Str(s.Tag)
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfTagModel = [8]string{
        0: "created_at",
        1: "updated_at",
        2: "tag",
        3: "date",
        4: "description",
        5: "latitude",
        6: "longitude",
        7: "zoom_level",
}

// Decode decodes TagModel from json.
func (s *TagModel) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagModel to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "tag":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Tag = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tag\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagModel")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTagModel) {
                                        name = jsonFieldsNameOfTagModel[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagModel) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagModel) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagModelStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagModelStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("tag")
                e.Str(s.Tag)
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfTagModelStore = [6]string{
        0: "tag",
        1: "date",
        2: "description",
        3: "latitude",
        4: "longitude",
        5: "zoom_level",
}

// Decode decodes TagModelStore from json.
func (s *TagModelStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagModelStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "tag":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Tag = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tag\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagModelStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTagModelStore) {
                                        name = jsonFieldsNameOfTagModelStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagModelStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagModelStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagModelUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagModelUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Tag.Set {
                        e.FieldStart("tag")
                        s.Tag.Encode(e)
                }
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDate)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
}

var jsonFieldsNameOfTagModelUpdate = [6]string{
        0: "tag",
        1: "date",
        2: "description",
        3: "latitude",
        4: "longitude",
        5: "zoom_level",
}

// Decode decodes TagModelUpdate from json.
func (s *TagModelUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagModelUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "tag":
                        if err := func() error {
                                s.Tag.Reset()
                                if err := s.Tag.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tag\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDate); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagModelUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagModelUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagModelUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTagRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes TagRead from json.
func (s *TagRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTagRead) {
                                        name = jsonFieldsNameOfTagRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TagSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TagSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfTagSingle = [1]string{
        0: "data",
}

// Decode decodes TagSingle from json.
func (s *TagSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TagSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TagSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTagSingle) {
                                        name = jsonFieldsNameOfTagSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TagSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TagSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Transaction) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Transaction) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.User.Set {
                        e.FieldStart("user")
                        s.User.Encode(e)
                }
        }
        {
                if s.GroupTitle.Set {
                        e.FieldStart("group_title")
                        s.GroupTitle.Encode(e)
                }
        }
        {
                e.FieldStart("transactions")
                e.ArrStart()
                for _, elem := range s.Transactions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

var jsonFieldsNameOfTransaction = [5]string{
        0: "created_at",
        1: "updated_at",
        2: "user",
        3: "group_title",
        4: "transactions",
}

// Decode decodes Transaction from json.
func (s *Transaction) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Transaction to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "user":
                        if err := func() error {
                                s.User.Reset()
                                if err := s.User.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"user\"")
                        }
                case "group_title":
                        if err := func() error {
                                s.GroupTitle.Reset()
                                if err := s.GroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"group_title\"")
                        }
                case "transactions":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                s.Transactions = make([]TransactionSplit, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TransactionSplit
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Transaction")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00010000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransaction) {
                                        name = jsonFieldsNameOfTransaction[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Transaction) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Transaction) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTransactionArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes TransactionArray from json.
func (s *TransactionArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]TransactionRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TransactionRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionArray) {
                                        name = jsonFieldsNameOfTransactionArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLink) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLink) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("link_type_id")
                e.Str(s.LinkTypeID)
        }
        {
                if s.LinkTypeName.Set {
                        e.FieldStart("link_type_name")
                        s.LinkTypeName.Encode(e)
                }
        }
        {
                e.FieldStart("inward_id")
                e.Str(s.InwardID)
        }
        {
                e.FieldStart("outward_id")
                e.Str(s.OutwardID)
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfTransactionLink = [7]string{
        0: "created_at",
        1: "updated_at",
        2: "link_type_id",
        3: "link_type_name",
        4: "inward_id",
        5: "outward_id",
        6: "notes",
}

// Decode decodes TransactionLink from json.
func (s *TransactionLink) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLink to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "link_type_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.LinkTypeID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_id\"")
                        }
                case "link_type_name":
                        if err := func() error {
                                s.LinkTypeName.Reset()
                                if err := s.LinkTypeName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_name\"")
                        }
                case "inward_id":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                v, err := d.Str()
                                s.InwardID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"inward_id\"")
                        }
                case "outward_id":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := d.Str()
                                s.OutwardID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"outward_id\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLink")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00110100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionLink) {
                                        name = jsonFieldsNameOfTransactionLink[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLink) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLink) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLinkArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLinkArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTransactionLinkArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes TransactionLinkArray from json.
func (s *TransactionLinkArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLinkArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]TransactionLinkRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TransactionLinkRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLinkArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionLinkArray) {
                                        name = jsonFieldsNameOfTransactionLinkArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLinkArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLinkArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLinkRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLinkRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTransactionLinkRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes TransactionLinkRead from json.
func (s *TransactionLinkRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLinkRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLinkRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionLinkRead) {
                                        name = jsonFieldsNameOfTransactionLinkRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLinkRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLinkRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLinkSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLinkSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfTransactionLinkSingle = [1]string{
        0: "data",
}

// Decode decodes TransactionLinkSingle from json.
func (s *TransactionLinkSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLinkSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLinkSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionLinkSingle) {
                                        name = jsonFieldsNameOfTransactionLinkSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLinkSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLinkSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLinkStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLinkStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("link_type_id")
                e.Str(s.LinkTypeID)
        }
        {
                if s.LinkTypeName.Set {
                        e.FieldStart("link_type_name")
                        s.LinkTypeName.Encode(e)
                }
        }
        {
                e.FieldStart("inward_id")
                e.Str(s.InwardID)
        }
        {
                e.FieldStart("outward_id")
                e.Str(s.OutwardID)
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfTransactionLinkStore = [5]string{
        0: "link_type_id",
        1: "link_type_name",
        2: "inward_id",
        3: "outward_id",
        4: "notes",
}

// Decode decodes TransactionLinkStore from json.
func (s *TransactionLinkStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLinkStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "link_type_id":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.LinkTypeID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_id\"")
                        }
                case "link_type_name":
                        if err := func() error {
                                s.LinkTypeName.Reset()
                                if err := s.LinkTypeName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_name\"")
                        }
                case "inward_id":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.InwardID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"inward_id\"")
                        }
                case "outward_id":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.OutwardID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"outward_id\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLinkStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001101,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionLinkStore) {
                                        name = jsonFieldsNameOfTransactionLinkStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLinkStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLinkStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionLinkUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionLinkUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.LinkTypeID.Set {
                        e.FieldStart("link_type_id")
                        s.LinkTypeID.Encode(e)
                }
        }
        {
                if s.LinkTypeName.Set {
                        e.FieldStart("link_type_name")
                        s.LinkTypeName.Encode(e)
                }
        }
        {
                if s.InwardID.Set {
                        e.FieldStart("inward_id")
                        s.InwardID.Encode(e)
                }
        }
        {
                if s.OutwardID.Set {
                        e.FieldStart("outward_id")
                        s.OutwardID.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
}

var jsonFieldsNameOfTransactionLinkUpdate = [5]string{
        0: "link_type_id",
        1: "link_type_name",
        2: "inward_id",
        3: "outward_id",
        4: "notes",
}

// Decode decodes TransactionLinkUpdate from json.
func (s *TransactionLinkUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionLinkUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "link_type_id":
                        if err := func() error {
                                s.LinkTypeID.Reset()
                                if err := s.LinkTypeID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_id\"")
                        }
                case "link_type_name":
                        if err := func() error {
                                s.LinkTypeName.Reset()
                                if err := s.LinkTypeName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"link_type_name\"")
                        }
                case "inward_id":
                        if err := func() error {
                                s.InwardID.Reset()
                                if err := s.InwardID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"inward_id\"")
                        }
                case "outward_id":
                        if err := func() error {
                                s.OutwardID.Reset()
                                if err := s.OutwardID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"outward_id\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionLinkUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionLinkUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionLinkUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfTransactionRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes TransactionRead from json.
func (s *TransactionRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionRead) {
                                        name = jsonFieldsNameOfTransactionRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfTransactionSingle = [1]string{
        0: "data",
}

// Decode decodes TransactionSingle from json.
func (s *TransactionSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionSingle) {
                                        name = jsonFieldsNameOfTransactionSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionSplit) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionSplit) encodeFields(e *jx.Encoder) {
        {
                if s.User.Set {
                        e.FieldStart("user")
                        s.User.Encode(e)
                }
        }
        {
                if s.TransactionJournalID.Set {
                        e.FieldStart("transaction_journal_id")
                        s.TransactionJournalID.Encode(e)
                }
        }
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("date")
                json.EncodeDateTime(e, s.Date)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyName.Set {
                        e.FieldStart("currency_name")
                        s.CurrencyName.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyCode.Set {
                        e.FieldStart("foreign_currency_code")
                        s.ForeignCurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignCurrencySymbol.Set {
                        e.FieldStart("foreign_currency_symbol")
                        s.ForeignCurrencySymbol.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyDecimalPlaces.Set {
                        e.FieldStart("foreign_currency_decimal_places")
                        s.ForeignCurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
        {
                e.FieldStart("source_id")
                s.SourceID.Encode(e)
        }
        {
                if s.SourceName.Set {
                        e.FieldStart("source_name")
                        s.SourceName.Encode(e)
                }
        }
        {
                if s.SourceIban.Set {
                        e.FieldStart("source_iban")
                        s.SourceIban.Encode(e)
                }
        }
        {
                if s.SourceType.Set {
                        e.FieldStart("source_type")
                        s.SourceType.Encode(e)
                }
        }
        {
                e.FieldStart("destination_id")
                s.DestinationID.Encode(e)
        }
        {
                if s.DestinationName.Set {
                        e.FieldStart("destination_name")
                        s.DestinationName.Encode(e)
                }
        }
        {
                if s.DestinationIban.Set {
                        e.FieldStart("destination_iban")
                        s.DestinationIban.Encode(e)
                }
        }
        {
                if s.DestinationType.Set {
                        e.FieldStart("destination_type")
                        s.DestinationType.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.BudgetName.Set {
                        e.FieldStart("budget_name")
                        s.BudgetName.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                if s.CategoryName.Set {
                        e.FieldStart("category_name")
                        s.CategoryName.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
        {
                if s.BillName.Set {
                        e.FieldStart("bill_name")
                        s.BillName.Encode(e)
                }
        }
        {
                if s.Reconciled.Set {
                        e.FieldStart("reconciled")
                        s.Reconciled.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.InternalReference.Set {
                        e.FieldStart("internal_reference")
                        s.InternalReference.Encode(e)
                }
        }
        {
                if s.ExternalID.Set {
                        e.FieldStart("external_id")
                        s.ExternalID.Encode(e)
                }
        }
        {
                if s.ExternalURL.Set {
                        e.FieldStart("external_url")
                        s.ExternalURL.Encode(e)
                }
        }
        {
                if s.OriginalSource.Set {
                        e.FieldStart("original_source")
                        s.OriginalSource.Encode(e)
                }
        }
        {
                if s.RecurrenceID.Set {
                        e.FieldStart("recurrence_id")
                        s.RecurrenceID.Encode(e)
                }
        }
        {
                if s.RecurrenceTotal.Set {
                        e.FieldStart("recurrence_total")
                        s.RecurrenceTotal.Encode(e)
                }
        }
        {
                if s.RecurrenceCount.Set {
                        e.FieldStart("recurrence_count")
                        s.RecurrenceCount.Encode(e)
                }
        }
        {
                if s.BunqPaymentID.Set {
                        e.FieldStart("bunq_payment_id")
                        s.BunqPaymentID.Encode(e)
                }
        }
        {
                if s.ImportHashV2.Set {
                        e.FieldStart("import_hash_v2")
                        s.ImportHashV2.Encode(e)
                }
        }
        {
                if s.SepaCc.Set {
                        e.FieldStart("sepa_cc")
                        s.SepaCc.Encode(e)
                }
        }
        {
                if s.SepaCtOp.Set {
                        e.FieldStart("sepa_ct_op")
                        s.SepaCtOp.Encode(e)
                }
        }
        {
                if s.SepaCtID.Set {
                        e.FieldStart("sepa_ct_id")
                        s.SepaCtID.Encode(e)
                }
        }
        {
                if s.SepaDb.Set {
                        e.FieldStart("sepa_db")
                        s.SepaDb.Encode(e)
                }
        }
        {
                if s.SepaCountry.Set {
                        e.FieldStart("sepa_country")
                        s.SepaCountry.Encode(e)
                }
        }
        {
                if s.SepaEp.Set {
                        e.FieldStart("sepa_ep")
                        s.SepaEp.Encode(e)
                }
        }
        {
                if s.SepaCi.Set {
                        e.FieldStart("sepa_ci")
                        s.SepaCi.Encode(e)
                }
        }
        {
                if s.SepaBatchID.Set {
                        e.FieldStart("sepa_batch_id")
                        s.SepaBatchID.Encode(e)
                }
        }
        {
                if s.InterestDate.Set {
                        e.FieldStart("interest_date")
                        s.InterestDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.BookDate.Set {
                        e.FieldStart("book_date")
                        s.BookDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ProcessDate.Set {
                        e.FieldStart("process_date")
                        s.ProcessDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.DueDate.Set {
                        e.FieldStart("due_date")
                        s.DueDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.PaymentDate.Set {
                        e.FieldStart("payment_date")
                        s.PaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.InvoiceDate.Set {
                        e.FieldStart("invoice_date")
                        s.InvoiceDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Latitude.Set {
                        e.FieldStart("latitude")
                        s.Latitude.Encode(e)
                }
        }
        {
                if s.Longitude.Set {
                        e.FieldStart("longitude")
                        s.Longitude.Encode(e)
                }
        }
        {
                if s.ZoomLevel.Set {
                        e.FieldStart("zoom_level")
                        s.ZoomLevel.Encode(e)
                }
        }
        {
                if s.HasAttachments.Set {
                        e.FieldStart("has_attachments")
                        s.HasAttachments.Encode(e)
                }
        }
}

var jsonFieldsNameOfTransactionSplit = [61]string{
        0:  "user",
        1:  "transaction_journal_id",
        2:  "type",
        3:  "date",
        4:  "order",
        5:  "currency_id",
        6:  "currency_code",
        7:  "currency_symbol",
        8:  "currency_name",
        9:  "currency_decimal_places",
        10: "foreign_currency_id",
        11: "foreign_currency_code",
        12: "foreign_currency_symbol",
        13: "foreign_currency_decimal_places",
        14: "amount",
        15: "foreign_amount",
        16: "description",
        17: "source_id",
        18: "source_name",
        19: "source_iban",
        20: "source_type",
        21: "destination_id",
        22: "destination_name",
        23: "destination_iban",
        24: "destination_type",
        25: "budget_id",
        26: "budget_name",
        27: "category_id",
        28: "category_name",
        29: "bill_id",
        30: "bill_name",
        31: "reconciled",
        32: "notes",
        33: "tags",
        34: "internal_reference",
        35: "external_id",
        36: "external_url",
        37: "original_source",
        38: "recurrence_id",
        39: "recurrence_total",
        40: "recurrence_count",
        41: "bunq_payment_id",
        42: "import_hash_v2",
        43: "sepa_cc",
        44: "sepa_ct_op",
        45: "sepa_ct_id",
        46: "sepa_db",
        47: "sepa_country",
        48: "sepa_ep",
        49: "sepa_ci",
        50: "sepa_batch_id",
        51: "interest_date",
        52: "book_date",
        53: "process_date",
        54: "due_date",
        55: "payment_date",
        56: "invoice_date",
        57: "latitude",
        58: "longitude",
        59: "zoom_level",
        60: "has_attachments",
}

// Decode decodes TransactionSplit from json.
func (s *TransactionSplit) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionSplit to nil")
        }
        var requiredBitSet [8]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "user":
                        if err := func() error {
                                s.User.Reset()
                                if err := s.User.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"user\"")
                        }
                case "transaction_journal_id":
                        if err := func() error {
                                s.TransactionJournalID.Reset()
                                if err := s.TransactionJournalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_journal_id\"")
                        }
                case "type":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "date":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Date = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_name":
                        if err := func() error {
                                s.CurrencyName.Reset()
                                if err := s.CurrencyName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_name\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "foreign_currency_code":
                        if err := func() error {
                                s.ForeignCurrencyCode.Reset()
                                if err := s.ForeignCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_code\"")
                        }
                case "foreign_currency_symbol":
                        if err := func() error {
                                s.ForeignCurrencySymbol.Reset()
                                if err := s.ForeignCurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_symbol\"")
                        }
                case "foreign_currency_decimal_places":
                        if err := func() error {
                                s.ForeignCurrencyDecimalPlaces.Reset()
                                if err := s.ForeignCurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_decimal_places\"")
                        }
                case "amount":
                        requiredBitSet[1] |= 1 << 6
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "description":
                        requiredBitSet[2] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "source_id":
                        requiredBitSet[2] |= 1 << 1
                        if err := func() error {
                                if err := s.SourceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "source_name":
                        if err := func() error {
                                s.SourceName.Reset()
                                if err := s.SourceName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_name\"")
                        }
                case "source_iban":
                        if err := func() error {
                                s.SourceIban.Reset()
                                if err := s.SourceIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_iban\"")
                        }
                case "source_type":
                        if err := func() error {
                                s.SourceType.Reset()
                                if err := s.SourceType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_type\"")
                        }
                case "destination_id":
                        requiredBitSet[2] |= 1 << 5
                        if err := func() error {
                                if err := s.DestinationID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "destination_name":
                        if err := func() error {
                                s.DestinationName.Reset()
                                if err := s.DestinationName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_name\"")
                        }
                case "destination_iban":
                        if err := func() error {
                                s.DestinationIban.Reset()
                                if err := s.DestinationIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_iban\"")
                        }
                case "destination_type":
                        if err := func() error {
                                s.DestinationType.Reset()
                                if err := s.DestinationType.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_type\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "budget_name":
                        if err := func() error {
                                s.BudgetName.Reset()
                                if err := s.BudgetName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_name\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "category_name":
                        if err := func() error {
                                s.CategoryName.Reset()
                                if err := s.CategoryName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_name\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                case "bill_name":
                        if err := func() error {
                                s.BillName.Reset()
                                if err := s.BillName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_name\"")
                        }
                case "reconciled":
                        if err := func() error {
                                s.Reconciled.Reset()
                                if err := s.Reconciled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"reconciled\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "internal_reference":
                        if err := func() error {
                                s.InternalReference.Reset()
                                if err := s.InternalReference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"internal_reference\"")
                        }
                case "external_id":
                        if err := func() error {
                                s.ExternalID.Reset()
                                if err := s.ExternalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_id\"")
                        }
                case "external_url":
                        if err := func() error {
                                s.ExternalURL.Reset()
                                if err := s.ExternalURL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_url\"")
                        }
                case "original_source":
                        if err := func() error {
                                s.OriginalSource.Reset()
                                if err := s.OriginalSource.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"original_source\"")
                        }
                case "recurrence_id":
                        if err := func() error {
                                s.RecurrenceID.Reset()
                                if err := s.RecurrenceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"recurrence_id\"")
                        }
                case "recurrence_total":
                        if err := func() error {
                                s.RecurrenceTotal.Reset()
                                if err := s.RecurrenceTotal.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"recurrence_total\"")
                        }
                case "recurrence_count":
                        if err := func() error {
                                s.RecurrenceCount.Reset()
                                if err := s.RecurrenceCount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"recurrence_count\"")
                        }
                case "bunq_payment_id":
                        if err := func() error {
                                s.BunqPaymentID.Reset()
                                if err := s.BunqPaymentID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bunq_payment_id\"")
                        }
                case "import_hash_v2":
                        if err := func() error {
                                s.ImportHashV2.Reset()
                                if err := s.ImportHashV2.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"import_hash_v2\"")
                        }
                case "sepa_cc":
                        if err := func() error {
                                s.SepaCc.Reset()
                                if err := s.SepaCc.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_cc\"")
                        }
                case "sepa_ct_op":
                        if err := func() error {
                                s.SepaCtOp.Reset()
                                if err := s.SepaCtOp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_op\"")
                        }
                case "sepa_ct_id":
                        if err := func() error {
                                s.SepaCtID.Reset()
                                if err := s.SepaCtID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_id\"")
                        }
                case "sepa_db":
                        if err := func() error {
                                s.SepaDb.Reset()
                                if err := s.SepaDb.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_db\"")
                        }
                case "sepa_country":
                        if err := func() error {
                                s.SepaCountry.Reset()
                                if err := s.SepaCountry.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_country\"")
                        }
                case "sepa_ep":
                        if err := func() error {
                                s.SepaEp.Reset()
                                if err := s.SepaEp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ep\"")
                        }
                case "sepa_ci":
                        if err := func() error {
                                s.SepaCi.Reset()
                                if err := s.SepaCi.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ci\"")
                        }
                case "sepa_batch_id":
                        if err := func() error {
                                s.SepaBatchID.Reset()
                                if err := s.SepaBatchID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_batch_id\"")
                        }
                case "interest_date":
                        if err := func() error {
                                s.InterestDate.Reset()
                                if err := s.InterestDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_date\"")
                        }
                case "book_date":
                        if err := func() error {
                                s.BookDate.Reset()
                                if err := s.BookDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"book_date\"")
                        }
                case "process_date":
                        if err := func() error {
                                s.ProcessDate.Reset()
                                if err := s.ProcessDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"process_date\"")
                        }
                case "due_date":
                        if err := func() error {
                                s.DueDate.Reset()
                                if err := s.DueDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"due_date\"")
                        }
                case "payment_date":
                        if err := func() error {
                                s.PaymentDate.Reset()
                                if err := s.PaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"payment_date\"")
                        }
                case "invoice_date":
                        if err := func() error {
                                s.InvoiceDate.Reset()
                                if err := s.InvoiceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"invoice_date\"")
                        }
                case "latitude":
                        if err := func() error {
                                s.Latitude.Reset()
                                if err := s.Latitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"latitude\"")
                        }
                case "longitude":
                        if err := func() error {
                                s.Longitude.Reset()
                                if err := s.Longitude.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"longitude\"")
                        }
                case "zoom_level":
                        if err := func() error {
                                s.ZoomLevel.Reset()
                                if err := s.ZoomLevel.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"zoom_level\"")
                        }
                case "has_attachments":
                        if err := func() error {
                                s.HasAttachments.Reset()
                                if err := s.HasAttachments.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"has_attachments\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionSplit")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [8]uint8{
                0b00001100,
                0b01000000,
                0b00100011,
                0b00000000,
                0b00000000,
                0b00000000,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionSplit) {
                                        name = jsonFieldsNameOfTransactionSplit[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionSplit) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionSplit) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionSplitStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionSplitStore) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                s.Type.Encode(e)
        }
        {
                e.FieldStart("date")
                json.EncodeDateTime(e, s.Date)
        }
        {
                e.FieldStart("amount")
                e.Str(s.Amount)
        }
        {
                e.FieldStart("description")
                e.Str(s.Description)
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyCode.Set {
                        e.FieldStart("foreign_currency_code")
                        s.ForeignCurrencyCode.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.BudgetName.Set {
                        e.FieldStart("budget_name")
                        s.BudgetName.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                if s.CategoryName.Set {
                        e.FieldStart("category_name")
                        s.CategoryName.Encode(e)
                }
        }
        {
                if s.SourceID.Set {
                        e.FieldStart("source_id")
                        s.SourceID.Encode(e)
                }
        }
        {
                if s.SourceName.Set {
                        e.FieldStart("source_name")
                        s.SourceName.Encode(e)
                }
        }
        {
                if s.DestinationID.Set {
                        e.FieldStart("destination_id")
                        s.DestinationID.Encode(e)
                }
        }
        {
                if s.DestinationName.Set {
                        e.FieldStart("destination_name")
                        s.DestinationName.Encode(e)
                }
        }
        {
                if s.Reconciled.Set {
                        e.FieldStart("reconciled")
                        s.Reconciled.Encode(e)
                }
        }
        {
                if s.PiggyBankID.Set {
                        e.FieldStart("piggy_bank_id")
                        s.PiggyBankID.Encode(e)
                }
        }
        {
                if s.PiggyBankName.Set {
                        e.FieldStart("piggy_bank_name")
                        s.PiggyBankName.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
        {
                if s.BillName.Set {
                        e.FieldStart("bill_name")
                        s.BillName.Encode(e)
                }
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.InternalReference.Set {
                        e.FieldStart("internal_reference")
                        s.InternalReference.Encode(e)
                }
        }
        {
                if s.ExternalID.Set {
                        e.FieldStart("external_id")
                        s.ExternalID.Encode(e)
                }
        }
        {
                if s.ExternalURL.Set {
                        e.FieldStart("external_url")
                        s.ExternalURL.Encode(e)
                }
        }
        {
                if s.BunqPaymentID.Set {
                        e.FieldStart("bunq_payment_id")
                        s.BunqPaymentID.Encode(e)
                }
        }
        {
                if s.SepaCc.Set {
                        e.FieldStart("sepa_cc")
                        s.SepaCc.Encode(e)
                }
        }
        {
                if s.SepaCtOp.Set {
                        e.FieldStart("sepa_ct_op")
                        s.SepaCtOp.Encode(e)
                }
        }
        {
                if s.SepaCtID.Set {
                        e.FieldStart("sepa_ct_id")
                        s.SepaCtID.Encode(e)
                }
        }
        {
                if s.SepaDb.Set {
                        e.FieldStart("sepa_db")
                        s.SepaDb.Encode(e)
                }
        }
        {
                if s.SepaCountry.Set {
                        e.FieldStart("sepa_country")
                        s.SepaCountry.Encode(e)
                }
        }
        {
                if s.SepaEp.Set {
                        e.FieldStart("sepa_ep")
                        s.SepaEp.Encode(e)
                }
        }
        {
                if s.SepaCi.Set {
                        e.FieldStart("sepa_ci")
                        s.SepaCi.Encode(e)
                }
        }
        {
                if s.SepaBatchID.Set {
                        e.FieldStart("sepa_batch_id")
                        s.SepaBatchID.Encode(e)
                }
        }
        {
                if s.InterestDate.Set {
                        e.FieldStart("interest_date")
                        s.InterestDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.BookDate.Set {
                        e.FieldStart("book_date")
                        s.BookDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ProcessDate.Set {
                        e.FieldStart("process_date")
                        s.ProcessDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.DueDate.Set {
                        e.FieldStart("due_date")
                        s.DueDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.PaymentDate.Set {
                        e.FieldStart("payment_date")
                        s.PaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.InvoiceDate.Set {
                        e.FieldStart("invoice_date")
                        s.InvoiceDate.Encode(e, json.EncodeDateTime)
                }
        }
}

var jsonFieldsNameOfTransactionSplitStore = [43]string{
        0:  "type",
        1:  "date",
        2:  "amount",
        3:  "description",
        4:  "order",
        5:  "currency_id",
        6:  "currency_code",
        7:  "foreign_amount",
        8:  "foreign_currency_id",
        9:  "foreign_currency_code",
        10: "budget_id",
        11: "budget_name",
        12: "category_id",
        13: "category_name",
        14: "source_id",
        15: "source_name",
        16: "destination_id",
        17: "destination_name",
        18: "reconciled",
        19: "piggy_bank_id",
        20: "piggy_bank_name",
        21: "bill_id",
        22: "bill_name",
        23: "tags",
        24: "notes",
        25: "internal_reference",
        26: "external_id",
        27: "external_url",
        28: "bunq_payment_id",
        29: "sepa_cc",
        30: "sepa_ct_op",
        31: "sepa_ct_id",
        32: "sepa_db",
        33: "sepa_country",
        34: "sepa_ep",
        35: "sepa_ci",
        36: "sepa_batch_id",
        37: "interest_date",
        38: "book_date",
        39: "process_date",
        40: "due_date",
        41: "payment_date",
        42: "invoice_date",
}

// Decode decodes TransactionSplitStore from json.
func (s *TransactionSplitStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionSplitStore to nil")
        }
        var requiredBitSet [6]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "date":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := json.DecodeDateTime(d)
                                s.Date = v
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "amount":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Amount = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "description":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Description = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "foreign_currency_code":
                        if err := func() error {
                                s.ForeignCurrencyCode.Reset()
                                if err := s.ForeignCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_code\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "budget_name":
                        if err := func() error {
                                s.BudgetName.Reset()
                                if err := s.BudgetName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_name\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "category_name":
                        if err := func() error {
                                s.CategoryName.Reset()
                                if err := s.CategoryName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_name\"")
                        }
                case "source_id":
                        if err := func() error {
                                s.SourceID.Reset()
                                if err := s.SourceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "source_name":
                        if err := func() error {
                                s.SourceName.Reset()
                                if err := s.SourceName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_name\"")
                        }
                case "destination_id":
                        if err := func() error {
                                s.DestinationID.Reset()
                                if err := s.DestinationID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "destination_name":
                        if err := func() error {
                                s.DestinationName.Reset()
                                if err := s.DestinationName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_name\"")
                        }
                case "reconciled":
                        if err := func() error {
                                s.Reconciled.Reset()
                                if err := s.Reconciled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"reconciled\"")
                        }
                case "piggy_bank_id":
                        if err := func() error {
                                s.PiggyBankID.Reset()
                                if err := s.PiggyBankID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_id\"")
                        }
                case "piggy_bank_name":
                        if err := func() error {
                                s.PiggyBankName.Reset()
                                if err := s.PiggyBankName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"piggy_bank_name\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                case "bill_name":
                        if err := func() error {
                                s.BillName.Reset()
                                if err := s.BillName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_name\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "internal_reference":
                        if err := func() error {
                                s.InternalReference.Reset()
                                if err := s.InternalReference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"internal_reference\"")
                        }
                case "external_id":
                        if err := func() error {
                                s.ExternalID.Reset()
                                if err := s.ExternalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_id\"")
                        }
                case "external_url":
                        if err := func() error {
                                s.ExternalURL.Reset()
                                if err := s.ExternalURL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_url\"")
                        }
                case "bunq_payment_id":
                        if err := func() error {
                                s.BunqPaymentID.Reset()
                                if err := s.BunqPaymentID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bunq_payment_id\"")
                        }
                case "sepa_cc":
                        if err := func() error {
                                s.SepaCc.Reset()
                                if err := s.SepaCc.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_cc\"")
                        }
                case "sepa_ct_op":
                        if err := func() error {
                                s.SepaCtOp.Reset()
                                if err := s.SepaCtOp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_op\"")
                        }
                case "sepa_ct_id":
                        if err := func() error {
                                s.SepaCtID.Reset()
                                if err := s.SepaCtID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_id\"")
                        }
                case "sepa_db":
                        if err := func() error {
                                s.SepaDb.Reset()
                                if err := s.SepaDb.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_db\"")
                        }
                case "sepa_country":
                        if err := func() error {
                                s.SepaCountry.Reset()
                                if err := s.SepaCountry.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_country\"")
                        }
                case "sepa_ep":
                        if err := func() error {
                                s.SepaEp.Reset()
                                if err := s.SepaEp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ep\"")
                        }
                case "sepa_ci":
                        if err := func() error {
                                s.SepaCi.Reset()
                                if err := s.SepaCi.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ci\"")
                        }
                case "sepa_batch_id":
                        if err := func() error {
                                s.SepaBatchID.Reset()
                                if err := s.SepaBatchID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_batch_id\"")
                        }
                case "interest_date":
                        if err := func() error {
                                s.InterestDate.Reset()
                                if err := s.InterestDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_date\"")
                        }
                case "book_date":
                        if err := func() error {
                                s.BookDate.Reset()
                                if err := s.BookDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"book_date\"")
                        }
                case "process_date":
                        if err := func() error {
                                s.ProcessDate.Reset()
                                if err := s.ProcessDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"process_date\"")
                        }
                case "due_date":
                        if err := func() error {
                                s.DueDate.Reset()
                                if err := s.DueDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"due_date\"")
                        }
                case "payment_date":
                        if err := func() error {
                                s.PaymentDate.Reset()
                                if err := s.PaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"payment_date\"")
                        }
                case "invoice_date":
                        if err := func() error {
                                s.InvoiceDate.Reset()
                                if err := s.InvoiceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"invoice_date\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionSplitStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [6]uint8{
                0b00001111,
                0b00000000,
                0b00000000,
                0b00000000,
                0b00000000,
                0b00000000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionSplitStore) {
                                        name = jsonFieldsNameOfTransactionSplitStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionSplitStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionSplitStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionSplitUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionSplitUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.TransactionJournalID.Set {
                        e.FieldStart("transaction_journal_id")
                        s.TransactionJournalID.Encode(e)
                }
        }
        {
                if s.Type.Set {
                        e.FieldStart("type")
                        s.Type.Encode(e)
                }
        }
        {
                if s.Date.Set {
                        e.FieldStart("date")
                        s.Date.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Amount.Set {
                        e.FieldStart("amount")
                        s.Amount.Encode(e)
                }
        }
        {
                if s.Description.Set {
                        e.FieldStart("description")
                        s.Description.Encode(e)
                }
        }
        {
                if s.Order.Set {
                        e.FieldStart("order")
                        s.Order.Encode(e)
                }
        }
        {
                if s.CurrencyID.Set {
                        e.FieldStart("currency_id")
                        s.CurrencyID.Encode(e)
                }
        }
        {
                if s.CurrencyCode.Set {
                        e.FieldStart("currency_code")
                        s.CurrencyCode.Encode(e)
                }
        }
        {
                if s.CurrencySymbol.Set {
                        e.FieldStart("currency_symbol")
                        s.CurrencySymbol.Encode(e)
                }
        }
        {
                if s.CurrencyName.Set {
                        e.FieldStart("currency_name")
                        s.CurrencyName.Encode(e)
                }
        }
        {
                if s.CurrencyDecimalPlaces.Set {
                        e.FieldStart("currency_decimal_places")
                        s.CurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.ForeignAmount.Set {
                        e.FieldStart("foreign_amount")
                        s.ForeignAmount.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyID.Set {
                        e.FieldStart("foreign_currency_id")
                        s.ForeignCurrencyID.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyCode.Set {
                        e.FieldStart("foreign_currency_code")
                        s.ForeignCurrencyCode.Encode(e)
                }
        }
        {
                if s.ForeignCurrencySymbol.Set {
                        e.FieldStart("foreign_currency_symbol")
                        s.ForeignCurrencySymbol.Encode(e)
                }
        }
        {
                if s.ForeignCurrencyDecimalPlaces.Set {
                        e.FieldStart("foreign_currency_decimal_places")
                        s.ForeignCurrencyDecimalPlaces.Encode(e)
                }
        }
        {
                if s.BudgetID.Set {
                        e.FieldStart("budget_id")
                        s.BudgetID.Encode(e)
                }
        }
        {
                if s.BudgetName.Set {
                        e.FieldStart("budget_name")
                        s.BudgetName.Encode(e)
                }
        }
        {
                if s.CategoryID.Set {
                        e.FieldStart("category_id")
                        s.CategoryID.Encode(e)
                }
        }
        {
                if s.CategoryName.Set {
                        e.FieldStart("category_name")
                        s.CategoryName.Encode(e)
                }
        }
        {
                if s.SourceID.Set {
                        e.FieldStart("source_id")
                        s.SourceID.Encode(e)
                }
        }
        {
                if s.SourceName.Set {
                        e.FieldStart("source_name")
                        s.SourceName.Encode(e)
                }
        }
        {
                if s.SourceIban.Set {
                        e.FieldStart("source_iban")
                        s.SourceIban.Encode(e)
                }
        }
        {
                if s.DestinationID.Set {
                        e.FieldStart("destination_id")
                        s.DestinationID.Encode(e)
                }
        }
        {
                if s.DestinationName.Set {
                        e.FieldStart("destination_name")
                        s.DestinationName.Encode(e)
                }
        }
        {
                if s.DestinationIban.Set {
                        e.FieldStart("destination_iban")
                        s.DestinationIban.Encode(e)
                }
        }
        {
                if s.Reconciled.Set {
                        e.FieldStart("reconciled")
                        s.Reconciled.Encode(e)
                }
        }
        {
                if s.BillID.Set {
                        e.FieldStart("bill_id")
                        s.BillID.Encode(e)
                }
        }
        {
                if s.BillName.Set {
                        e.FieldStart("bill_name")
                        s.BillName.Encode(e)
                }
        }
        {
                if s.Tags.Set {
                        e.FieldStart("tags")
                        s.Tags.Encode(e)
                }
        }
        {
                if s.Notes.Set {
                        e.FieldStart("notes")
                        s.Notes.Encode(e)
                }
        }
        {
                if s.InternalReference.Set {
                        e.FieldStart("internal_reference")
                        s.InternalReference.Encode(e)
                }
        }
        {
                if s.ExternalID.Set {
                        e.FieldStart("external_id")
                        s.ExternalID.Encode(e)
                }
        }
        {
                if s.ExternalURL.Set {
                        e.FieldStart("external_url")
                        s.ExternalURL.Encode(e)
                }
        }
        {
                if s.BunqPaymentID.Set {
                        e.FieldStart("bunq_payment_id")
                        s.BunqPaymentID.Encode(e)
                }
        }
        {
                if s.SepaCc.Set {
                        e.FieldStart("sepa_cc")
                        s.SepaCc.Encode(e)
                }
        }
        {
                if s.SepaCtOp.Set {
                        e.FieldStart("sepa_ct_op")
                        s.SepaCtOp.Encode(e)
                }
        }
        {
                if s.SepaCtID.Set {
                        e.FieldStart("sepa_ct_id")
                        s.SepaCtID.Encode(e)
                }
        }
        {
                if s.SepaDb.Set {
                        e.FieldStart("sepa_db")
                        s.SepaDb.Encode(e)
                }
        }
        {
                if s.SepaCountry.Set {
                        e.FieldStart("sepa_country")
                        s.SepaCountry.Encode(e)
                }
        }
        {
                if s.SepaEp.Set {
                        e.FieldStart("sepa_ep")
                        s.SepaEp.Encode(e)
                }
        }
        {
                if s.SepaCi.Set {
                        e.FieldStart("sepa_ci")
                        s.SepaCi.Encode(e)
                }
        }
        {
                if s.SepaBatchID.Set {
                        e.FieldStart("sepa_batch_id")
                        s.SepaBatchID.Encode(e)
                }
        }
        {
                if s.InterestDate.Set {
                        e.FieldStart("interest_date")
                        s.InterestDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.BookDate.Set {
                        e.FieldStart("book_date")
                        s.BookDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.ProcessDate.Set {
                        e.FieldStart("process_date")
                        s.ProcessDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.DueDate.Set {
                        e.FieldStart("due_date")
                        s.DueDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.PaymentDate.Set {
                        e.FieldStart("payment_date")
                        s.PaymentDate.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.InvoiceDate.Set {
                        e.FieldStart("invoice_date")
                        s.InvoiceDate.Encode(e, json.EncodeDateTime)
                }
        }
}

var jsonFieldsNameOfTransactionSplitUpdate = [49]string{
        0:  "transaction_journal_id",
        1:  "type",
        2:  "date",
        3:  "amount",
        4:  "description",
        5:  "order",
        6:  "currency_id",
        7:  "currency_code",
        8:  "currency_symbol",
        9:  "currency_name",
        10: "currency_decimal_places",
        11: "foreign_amount",
        12: "foreign_currency_id",
        13: "foreign_currency_code",
        14: "foreign_currency_symbol",
        15: "foreign_currency_decimal_places",
        16: "budget_id",
        17: "budget_name",
        18: "category_id",
        19: "category_name",
        20: "source_id",
        21: "source_name",
        22: "source_iban",
        23: "destination_id",
        24: "destination_name",
        25: "destination_iban",
        26: "reconciled",
        27: "bill_id",
        28: "bill_name",
        29: "tags",
        30: "notes",
        31: "internal_reference",
        32: "external_id",
        33: "external_url",
        34: "bunq_payment_id",
        35: "sepa_cc",
        36: "sepa_ct_op",
        37: "sepa_ct_id",
        38: "sepa_db",
        39: "sepa_country",
        40: "sepa_ep",
        41: "sepa_ci",
        42: "sepa_batch_id",
        43: "interest_date",
        44: "book_date",
        45: "process_date",
        46: "due_date",
        47: "payment_date",
        48: "invoice_date",
}

// Decode decodes TransactionSplitUpdate from json.
func (s *TransactionSplitUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionSplitUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "transaction_journal_id":
                        if err := func() error {
                                s.TransactionJournalID.Reset()
                                if err := s.TransactionJournalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transaction_journal_id\"")
                        }
                case "type":
                        if err := func() error {
                                s.Type.Reset()
                                if err := s.Type.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date.Reset()
                                if err := s.Date.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                case "amount":
                        if err := func() error {
                                s.Amount.Reset()
                                if err := s.Amount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"amount\"")
                        }
                case "description":
                        if err := func() error {
                                s.Description.Reset()
                                if err := s.Description.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"description\"")
                        }
                case "order":
                        if err := func() error {
                                s.Order.Reset()
                                if err := s.Order.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"order\"")
                        }
                case "currency_id":
                        if err := func() error {
                                s.CurrencyID.Reset()
                                if err := s.CurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_id\"")
                        }
                case "currency_code":
                        if err := func() error {
                                s.CurrencyCode.Reset()
                                if err := s.CurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_code\"")
                        }
                case "currency_symbol":
                        if err := func() error {
                                s.CurrencySymbol.Reset()
                                if err := s.CurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_symbol\"")
                        }
                case "currency_name":
                        if err := func() error {
                                s.CurrencyName.Reset()
                                if err := s.CurrencyName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_name\"")
                        }
                case "currency_decimal_places":
                        if err := func() error {
                                s.CurrencyDecimalPlaces.Reset()
                                if err := s.CurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"currency_decimal_places\"")
                        }
                case "foreign_amount":
                        if err := func() error {
                                s.ForeignAmount.Reset()
                                if err := s.ForeignAmount.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_amount\"")
                        }
                case "foreign_currency_id":
                        if err := func() error {
                                s.ForeignCurrencyID.Reset()
                                if err := s.ForeignCurrencyID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_id\"")
                        }
                case "foreign_currency_code":
                        if err := func() error {
                                s.ForeignCurrencyCode.Reset()
                                if err := s.ForeignCurrencyCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_code\"")
                        }
                case "foreign_currency_symbol":
                        if err := func() error {
                                s.ForeignCurrencySymbol.Reset()
                                if err := s.ForeignCurrencySymbol.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_symbol\"")
                        }
                case "foreign_currency_decimal_places":
                        if err := func() error {
                                s.ForeignCurrencyDecimalPlaces.Reset()
                                if err := s.ForeignCurrencyDecimalPlaces.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"foreign_currency_decimal_places\"")
                        }
                case "budget_id":
                        if err := func() error {
                                s.BudgetID.Reset()
                                if err := s.BudgetID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_id\"")
                        }
                case "budget_name":
                        if err := func() error {
                                s.BudgetName.Reset()
                                if err := s.BudgetName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"budget_name\"")
                        }
                case "category_id":
                        if err := func() error {
                                s.CategoryID.Reset()
                                if err := s.CategoryID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_id\"")
                        }
                case "category_name":
                        if err := func() error {
                                s.CategoryName.Reset()
                                if err := s.CategoryName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"category_name\"")
                        }
                case "source_id":
                        if err := func() error {
                                s.SourceID.Reset()
                                if err := s.SourceID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_id\"")
                        }
                case "source_name":
                        if err := func() error {
                                s.SourceName.Reset()
                                if err := s.SourceName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_name\"")
                        }
                case "source_iban":
                        if err := func() error {
                                s.SourceIban.Reset()
                                if err := s.SourceIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"source_iban\"")
                        }
                case "destination_id":
                        if err := func() error {
                                s.DestinationID.Reset()
                                if err := s.DestinationID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_id\"")
                        }
                case "destination_name":
                        if err := func() error {
                                s.DestinationName.Reset()
                                if err := s.DestinationName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_name\"")
                        }
                case "destination_iban":
                        if err := func() error {
                                s.DestinationIban.Reset()
                                if err := s.DestinationIban.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"destination_iban\"")
                        }
                case "reconciled":
                        if err := func() error {
                                s.Reconciled.Reset()
                                if err := s.Reconciled.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"reconciled\"")
                        }
                case "bill_id":
                        if err := func() error {
                                s.BillID.Reset()
                                if err := s.BillID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_id\"")
                        }
                case "bill_name":
                        if err := func() error {
                                s.BillName.Reset()
                                if err := s.BillName.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bill_name\"")
                        }
                case "tags":
                        if err := func() error {
                                s.Tags.Reset()
                                if err := s.Tags.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"tags\"")
                        }
                case "notes":
                        if err := func() error {
                                s.Notes.Reset()
                                if err := s.Notes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"notes\"")
                        }
                case "internal_reference":
                        if err := func() error {
                                s.InternalReference.Reset()
                                if err := s.InternalReference.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"internal_reference\"")
                        }
                case "external_id":
                        if err := func() error {
                                s.ExternalID.Reset()
                                if err := s.ExternalID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_id\"")
                        }
                case "external_url":
                        if err := func() error {
                                s.ExternalURL.Reset()
                                if err := s.ExternalURL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"external_url\"")
                        }
                case "bunq_payment_id":
                        if err := func() error {
                                s.BunqPaymentID.Reset()
                                if err := s.BunqPaymentID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"bunq_payment_id\"")
                        }
                case "sepa_cc":
                        if err := func() error {
                                s.SepaCc.Reset()
                                if err := s.SepaCc.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_cc\"")
                        }
                case "sepa_ct_op":
                        if err := func() error {
                                s.SepaCtOp.Reset()
                                if err := s.SepaCtOp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_op\"")
                        }
                case "sepa_ct_id":
                        if err := func() error {
                                s.SepaCtID.Reset()
                                if err := s.SepaCtID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ct_id\"")
                        }
                case "sepa_db":
                        if err := func() error {
                                s.SepaDb.Reset()
                                if err := s.SepaDb.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_db\"")
                        }
                case "sepa_country":
                        if err := func() error {
                                s.SepaCountry.Reset()
                                if err := s.SepaCountry.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_country\"")
                        }
                case "sepa_ep":
                        if err := func() error {
                                s.SepaEp.Reset()
                                if err := s.SepaEp.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ep\"")
                        }
                case "sepa_ci":
                        if err := func() error {
                                s.SepaCi.Reset()
                                if err := s.SepaCi.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_ci\"")
                        }
                case "sepa_batch_id":
                        if err := func() error {
                                s.SepaBatchID.Reset()
                                if err := s.SepaBatchID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sepa_batch_id\"")
                        }
                case "interest_date":
                        if err := func() error {
                                s.InterestDate.Reset()
                                if err := s.InterestDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"interest_date\"")
                        }
                case "book_date":
                        if err := func() error {
                                s.BookDate.Reset()
                                if err := s.BookDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"book_date\"")
                        }
                case "process_date":
                        if err := func() error {
                                s.ProcessDate.Reset()
                                if err := s.ProcessDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"process_date\"")
                        }
                case "due_date":
                        if err := func() error {
                                s.DueDate.Reset()
                                if err := s.DueDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"due_date\"")
                        }
                case "payment_date":
                        if err := func() error {
                                s.PaymentDate.Reset()
                                if err := s.PaymentDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"payment_date\"")
                        }
                case "invoice_date":
                        if err := func() error {
                                s.InvoiceDate.Reset()
                                if err := s.InvoiceDate.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"invoice_date\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionSplitUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionSplitUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionSplitUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionStore) encodeFields(e *jx.Encoder) {
        {
                if s.ErrorIfDuplicateHash.Set {
                        e.FieldStart("error_if_duplicate_hash")
                        s.ErrorIfDuplicateHash.Encode(e)
                }
        }
        {
                if s.ApplyRules.Set {
                        e.FieldStart("apply_rules")
                        s.ApplyRules.Encode(e)
                }
        }
        {
                if s.FireWebhooks.Set {
                        e.FieldStart("fire_webhooks")
                        s.FireWebhooks.Encode(e)
                }
        }
        {
                if s.GroupTitle.Set {
                        e.FieldStart("group_title")
                        s.GroupTitle.Encode(e)
                }
        }
        {
                e.FieldStart("transactions")
                e.ArrStart()
                for _, elem := range s.Transactions {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
}

var jsonFieldsNameOfTransactionStore = [5]string{
        0: "error_if_duplicate_hash",
        1: "apply_rules",
        2: "fire_webhooks",
        3: "group_title",
        4: "transactions",
}

// Decode decodes TransactionStore from json.
func (s *TransactionStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionStore to nil")
        }
        var requiredBitSet [1]uint8
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "error_if_duplicate_hash":
                        if err := func() error {
                                s.ErrorIfDuplicateHash.Reset()
                                if err := s.ErrorIfDuplicateHash.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"error_if_duplicate_hash\"")
                        }
                case "apply_rules":
                        if err := func() error {
                                s.ApplyRules.Reset()
                                if err := s.ApplyRules.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"apply_rules\"")
                        }
                case "fire_webhooks":
                        if err := func() error {
                                s.FireWebhooks.Reset()
                                if err := s.FireWebhooks.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"fire_webhooks\"")
                        }
                case "group_title":
                        if err := func() error {
                                s.GroupTitle.Reset()
                                if err := s.GroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"group_title\"")
                        }
                case "transactions":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                s.Transactions = make([]TransactionSplitStore, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TransactionSplitStore
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00010000,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfTransactionStore) {
                                        name = jsonFieldsNameOfTransactionStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes TransactionTypeProperty as json.
func (s TransactionTypeProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes TransactionTypeProperty from json.
func (s *TransactionTypeProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionTypeProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch TransactionTypeProperty(v) {
        case TransactionTypePropertyWithdrawal:
                *s = TransactionTypePropertyWithdrawal
        case TransactionTypePropertyDeposit:
                *s = TransactionTypePropertyDeposit
        case TransactionTypePropertyTransfer:
                *s = TransactionTypePropertyTransfer
        case TransactionTypePropertyReconciliation:
                *s = TransactionTypePropertyReconciliation
        case TransactionTypePropertyOpeningBalance:
                *s = TransactionTypePropertyOpeningBalance
        default:
                *s = TransactionTypeProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s TransactionTypeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionTypeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransactionUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransactionUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.ApplyRules.Set {
                        e.FieldStart("apply_rules")
                        s.ApplyRules.Encode(e)
                }
        }
        {
                if s.FireWebhooks.Set {
                        e.FieldStart("fire_webhooks")
                        s.FireWebhooks.Encode(e)
                }
        }
        {
                if s.GroupTitle.Set {
                        e.FieldStart("group_title")
                        s.GroupTitle.Encode(e)
                }
        }
        {
                if s.Transactions != nil {
                        e.FieldStart("transactions")
                        e.ArrStart()
                        for _, elem := range s.Transactions {
                                elem.Encode(e)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfTransactionUpdate = [4]string{
        0: "apply_rules",
        1: "fire_webhooks",
        2: "group_title",
        3: "transactions",
}

// Decode decodes TransactionUpdate from json.
func (s *TransactionUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode TransactionUpdate to nil")
        }
        s.setDefaults()

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "apply_rules":
                        if err := func() error {
                                s.ApplyRules.Reset()
                                if err := s.ApplyRules.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"apply_rules\"")
                        }
                case "fire_webhooks":
                        if err := func() error {
                                s.FireWebhooks.Reset()
                                if err := s.FireWebhooks.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"fire_webhooks\"")
                        }
                case "group_title":
                        if err := func() error {
                                s.GroupTitle.Reset()
                                if err := s.GroupTitle.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"group_title\"")
                        }
                case "transactions":
                        if err := func() error {
                                s.Transactions = make([]TransactionSplitUpdate, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem TransactionSplitUpdate
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Transactions = append(s.Transactions, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"transactions\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode TransactionUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TransactionUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransactionUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Unauthenticated) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Unauthenticated) encodeFields(e *jx.Encoder) {
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
        {
                if s.Exception.Set {
                        e.FieldStart("exception")
                        s.Exception.Encode(e)
                }
        }
}

var jsonFieldsNameOfUnauthenticated = [2]string{
        0: "message",
        1: "exception",
}

// Decode decodes Unauthenticated from json.
func (s *Unauthenticated) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Unauthenticated to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                case "exception":
                        if err := func() error {
                                s.Exception.Reset()
                                if err := s.Exception.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"exception\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Unauthenticated")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Unauthenticated) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Unauthenticated) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *User) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *User) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                e.FieldStart("email")
                e.Str(s.Email)
        }
        {
                if s.Blocked.Set {
                        e.FieldStart("blocked")
                        s.Blocked.Encode(e)
                }
        }
        {
                if s.BlockedCode.Set {
                        e.FieldStart("blocked_code")
                        s.BlockedCode.Encode(e)
                }
        }
        {
                if s.Role.Set {
                        e.FieldStart("role")
                        s.Role.Encode(e)
                }
        }
}

var jsonFieldsNameOfUser = [6]string{
        0: "created_at",
        1: "updated_at",
        2: "email",
        3: "blocked",
        4: "blocked_code",
        5: "role",
}

// Decode decodes User from json.
func (s *User) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode User to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "email":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                v, err := d.Str()
                                s.Email = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"email\"")
                        }
                case "blocked":
                        if err := func() error {
                                s.Blocked.Reset()
                                if err := s.Blocked.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"blocked\"")
                        }
                case "blocked_code":
                        if err := func() error {
                                s.BlockedCode.Reset()
                                if err := s.BlockedCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"blocked_code\"")
                        }
                case "role":
                        if err := func() error {
                                s.Role.Reset()
                                if err := s.Role.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"role\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode User")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000100,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfUser) {
                                        name = jsonFieldsNameOfUser[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *User) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *User) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfUserArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes UserArray from json.
func (s *UserArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode UserArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]UserRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem UserRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode UserArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfUserArray) {
                                        name = jsonFieldsNameOfUserArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes UserBlockedCodeProperty as json.
func (s UserBlockedCodeProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes UserBlockedCodeProperty from json.
func (s *UserBlockedCodeProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode UserBlockedCodeProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch UserBlockedCodeProperty(v) {
        case UserBlockedCodePropertyEmailChanged:
                *s = UserBlockedCodePropertyEmailChanged
        default:
                *s = UserBlockedCodeProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s UserBlockedCodeProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserBlockedCodeProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfUserRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes UserRead from json.
func (s *UserRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode UserRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode UserRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfUserRead) {
                                        name = jsonFieldsNameOfUserRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes UserRoleProperty as json.
func (s UserRoleProperty) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes UserRoleProperty from json.
func (s *UserRoleProperty) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode UserRoleProperty to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch UserRoleProperty(v) {
        case UserRolePropertyOwner:
                *s = UserRolePropertyOwner
        case UserRolePropertyDemo:
                *s = UserRolePropertyDemo
        default:
                *s = UserRoleProperty(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s UserRoleProperty) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserRoleProperty) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfUserSingle = [1]string{
        0: "data",
}

// Decode decodes UserSingle from json.
func (s *UserSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode UserSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode UserSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfUserSingle) {
                                        name = jsonFieldsNameOfUserSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ValidationError) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ValidationError) encodeFields(e *jx.Encoder) {
        {
                if s.Message.Set {
                        e.FieldStart("message")
                        s.Message.Encode(e)
                }
        }
        {
                if s.Errors.Set {
                        e.FieldStart("errors")
                        s.Errors.Encode(e)
                }
        }
}

var jsonFieldsNameOfValidationError = [2]string{
        0: "message",
        1: "errors",
}

// Decode decodes ValidationError from json.
func (s *ValidationError) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ValidationError to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "message":
                        if err := func() error {
                                s.Message.Reset()
                                if err := s.Message.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"message\"")
                        }
                case "errors":
                        if err := func() error {
                                s.Errors.Reset()
                                if err := s.Errors.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"errors\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ValidationError")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ValidationError) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ValidationError) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ValidationErrorErrors) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ValidationErrorErrors) encodeFields(e *jx.Encoder) {
        {
                if s.Email != nil {
                        e.FieldStart("email")
                        e.ArrStart()
                        for _, elem := range s.Email {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Blocked != nil {
                        e.FieldStart("blocked")
                        e.ArrStart()
                        for _, elem := range s.Blocked {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Role != nil {
                        e.FieldStart("role")
                        e.ArrStart()
                        for _, elem := range s.Role {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.BlockedCode != nil {
                        e.FieldStart("blocked_code")
                        e.ArrStart()
                        for _, elem := range s.BlockedCode {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Name != nil {
                        e.FieldStart("name")
                        e.ArrStart()
                        for _, elem := range s.Name {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Type != nil {
                        e.FieldStart("type")
                        e.ArrStart()
                        for _, elem := range s.Type {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Iban != nil {
                        e.FieldStart("iban")
                        e.ArrStart()
                        for _, elem := range s.Iban {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Start != nil {
                        e.FieldStart("start")
                        e.ArrStart()
                        for _, elem := range s.Start {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.End != nil {
                        e.FieldStart("end")
                        e.ArrStart()
                        for _, elem := range s.End {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
        {
                if s.Date != nil {
                        e.FieldStart("date")
                        e.ArrStart()
                        for _, elem := range s.Date {
                                e.Str(elem)
                        }
                        e.ArrEnd()
                }
        }
}

var jsonFieldsNameOfValidationErrorErrors = [10]string{
        0: "email",
        1: "blocked",
        2: "role",
        3: "blocked_code",
        4: "name",
        5: "type",
        6: "iban",
        7: "start",
        8: "end",
        9: "date",
}

// Decode decodes ValidationErrorErrors from json.
func (s *ValidationErrorErrors) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode ValidationErrorErrors to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "email":
                        if err := func() error {
                                s.Email = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Email = append(s.Email, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"email\"")
                        }
                case "blocked":
                        if err := func() error {
                                s.Blocked = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Blocked = append(s.Blocked, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"blocked\"")
                        }
                case "role":
                        if err := func() error {
                                s.Role = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Role = append(s.Role, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"role\"")
                        }
                case "blocked_code":
                        if err := func() error {
                                s.BlockedCode = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.BlockedCode = append(s.BlockedCode, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"blocked_code\"")
                        }
                case "name":
                        if err := func() error {
                                s.Name = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Name = append(s.Name, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"name\"")
                        }
                case "type":
                        if err := func() error {
                                s.Type = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Type = append(s.Type, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "iban":
                        if err := func() error {
                                s.Iban = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Iban = append(s.Iban, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"iban\"")
                        }
                case "start":
                        if err := func() error {
                                s.Start = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Start = append(s.Start, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"start\"")
                        }
                case "end":
                        if err := func() error {
                                s.End = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.End = append(s.End, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"end\"")
                        }
                case "date":
                        if err := func() error {
                                s.Date = make([]string, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem string
                                        v, err := d.Str()
                                        elem = string(v)
                                        if err != nil {
                                                return err
                                        }
                                        s.Date = append(s.Date, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"date\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode ValidationErrorErrors")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ValidationErrorErrors) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ValidationErrorErrors) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Webhook) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Webhook) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                if s.Secret.Set {
                        e.FieldStart("secret")
                        s.Secret.Encode(e)
                }
        }
        {
                e.FieldStart("trigger")
                s.Trigger.Encode(e)
        }
        {
                e.FieldStart("response")
                s.Response.Encode(e)
        }
        {
                e.FieldStart("delivery")
                s.Delivery.Encode(e)
        }
        {
                e.FieldStart("url")
                e.Str(s.URL)
        }
}

var jsonFieldsNameOfWebhook = [9]string{
        0: "created_at",
        1: "updated_at",
        2: "active",
        3: "title",
        4: "secret",
        5: "trigger",
        6: "response",
        7: "delivery",
        8: "url",
}

// Decode decodes Webhook from json.
func (s *Webhook) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode Webhook to nil")
        }
        var requiredBitSet [2]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "secret":
                        if err := func() error {
                                s.Secret.Reset()
                                if err := s.Secret.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"secret\"")
                        }
                case "trigger":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "response":
                        requiredBitSet[0] |= 1 << 6
                        if err := func() error {
                                if err := s.Response.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"response\"")
                        }
                case "delivery":
                        requiredBitSet[0] |= 1 << 7
                        if err := func() error {
                                if err := s.Delivery.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"delivery\"")
                        }
                case "url":
                        requiredBitSet[1] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.URL = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"url\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode Webhook")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [2]uint8{
                0b11101000,
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhook) {
                                        name = jsonFieldsNameOfWebhook[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *Webhook) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Webhook) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfWebhookArray = [3]string{
        0: "data",
        1: "meta",
        2: "links",
}

// Decode decodes WebhookArray from json.
func (s *WebhookArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]WebhookRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem WebhookRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookArray) {
                                        name = jsonFieldsNameOfWebhookArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookAttempt) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookAttempt) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.WebhookMessageID.Set {
                        e.FieldStart("webhook_message_id")
                        s.WebhookMessageID.Encode(e)
                }
        }
        {
                if s.StatusCode.Set {
                        e.FieldStart("status_code")
                        s.StatusCode.Encode(e)
                }
        }
        {
                if s.Logs.Set {
                        e.FieldStart("logs")
                        s.Logs.Encode(e)
                }
        }
        {
                if s.Response.Set {
                        e.FieldStart("response")
                        s.Response.Encode(e)
                }
        }
}

var jsonFieldsNameOfWebhookAttempt = [6]string{
        0: "created_at",
        1: "updated_at",
        2: "webhook_message_id",
        3: "status_code",
        4: "logs",
        5: "response",
}

// Decode decodes WebhookAttempt from json.
func (s *WebhookAttempt) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookAttempt to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "webhook_message_id":
                        if err := func() error {
                                s.WebhookMessageID.Reset()
                                if err := s.WebhookMessageID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"webhook_message_id\"")
                        }
                case "status_code":
                        if err := func() error {
                                s.StatusCode.Reset()
                                if err := s.StatusCode.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"status_code\"")
                        }
                case "logs":
                        if err := func() error {
                                s.Logs.Reset()
                                if err := s.Logs.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"logs\"")
                        }
                case "response":
                        if err := func() error {
                                s.Response.Reset()
                                if err := s.Response.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"response\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookAttempt")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookAttempt) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookAttempt) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookAttemptArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookAttemptArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfWebhookAttemptArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes WebhookAttemptArray from json.
func (s *WebhookAttemptArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookAttemptArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]WebhookAttemptRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem WebhookAttemptRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookAttemptArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookAttemptArray) {
                                        name = jsonFieldsNameOfWebhookAttemptArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookAttemptArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookAttemptArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookAttemptRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookAttemptRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfWebhookAttemptRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes WebhookAttemptRead from json.
func (s *WebhookAttemptRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookAttemptRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookAttemptRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookAttemptRead) {
                                        name = jsonFieldsNameOfWebhookAttemptRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookAttemptRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookAttemptRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookAttemptSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookAttemptSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfWebhookAttemptSingle = [1]string{
        0: "data",
}

// Decode decodes WebhookAttemptSingle from json.
func (s *WebhookAttemptSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookAttemptSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookAttemptSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookAttemptSingle) {
                                        name = jsonFieldsNameOfWebhookAttemptSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookAttemptSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookAttemptSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookDelivery as json.
func (s WebhookDelivery) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes WebhookDelivery from json.
func (s *WebhookDelivery) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookDelivery to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch WebhookDelivery(v) {
        case WebhookDeliveryJSON:
                *s = WebhookDeliveryJSON
        default:
                *s = WebhookDelivery(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhookDelivery) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookDelivery) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookMessage) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookMessage) encodeFields(e *jx.Encoder) {
        {
                if s.CreatedAt.Set {
                        e.FieldStart("created_at")
                        s.CreatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.UpdatedAt.Set {
                        e.FieldStart("updated_at")
                        s.UpdatedAt.Encode(e, json.EncodeDateTime)
                }
        }
        {
                if s.Sent.Set {
                        e.FieldStart("sent")
                        s.Sent.Encode(e)
                }
        }
        {
                if s.Errored.Set {
                        e.FieldStart("errored")
                        s.Errored.Encode(e)
                }
        }
        {
                if s.WebhookID.Set {
                        e.FieldStart("webhook_id")
                        s.WebhookID.Encode(e)
                }
        }
        {
                if s.UUID.Set {
                        e.FieldStart("uuid")
                        s.UUID.Encode(e)
                }
        }
        {
                if s.String.Set {
                        e.FieldStart("string")
                        s.String.Encode(e)
                }
        }
}

var jsonFieldsNameOfWebhookMessage = [7]string{
        0: "created_at",
        1: "updated_at",
        2: "sent",
        3: "errored",
        4: "webhook_id",
        5: "uuid",
        6: "string",
}

// Decode decodes WebhookMessage from json.
func (s *WebhookMessage) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookMessage to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "created_at":
                        if err := func() error {
                                s.CreatedAt.Reset()
                                if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"created_at\"")
                        }
                case "updated_at":
                        if err := func() error {
                                s.UpdatedAt.Reset()
                                if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"updated_at\"")
                        }
                case "sent":
                        if err := func() error {
                                s.Sent.Reset()
                                if err := s.Sent.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"sent\"")
                        }
                case "errored":
                        if err := func() error {
                                s.Errored.Reset()
                                if err := s.Errored.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"errored\"")
                        }
                case "webhook_id":
                        if err := func() error {
                                s.WebhookID.Reset()
                                if err := s.WebhookID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"webhook_id\"")
                        }
                case "uuid":
                        if err := func() error {
                                s.UUID.Reset()
                                if err := s.UUID.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"uuid\"")
                        }
                case "string":
                        if err := func() error {
                                s.String.Reset()
                                if err := s.String.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"string\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookMessage")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookMessage) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookMessage) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookMessageArray) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookMessageArray) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                e.ArrStart()
                for _, elem := range s.Data {
                        elem.Encode(e)
                }
                e.ArrEnd()
        }
        {
                e.FieldStart("meta")
                s.Meta.Encode(e)
        }
}

var jsonFieldsNameOfWebhookMessageArray = [2]string{
        0: "data",
        1: "meta",
}

// Decode decodes WebhookMessageArray from json.
func (s *WebhookMessageArray) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookMessageArray to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                s.Data = make([]WebhookMessageRead, 0)
                                if err := d.Arr(func(d *jx.Decoder) error {
                                        var elem WebhookMessageRead
                                        if err := elem.Decode(d); err != nil {
                                                return err
                                        }
                                        s.Data = append(s.Data, elem)
                                        return nil
                                }); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                case "meta":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                if err := s.Meta.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"meta\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookMessageArray")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000011,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookMessageArray) {
                                        name = jsonFieldsNameOfWebhookMessageArray[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookMessageArray) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookMessageArray) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookMessageRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookMessageRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
}

var jsonFieldsNameOfWebhookMessageRead = [3]string{
        0: "type",
        1: "id",
        2: "attributes",
}

// Decode decodes WebhookMessageRead from json.
func (s *WebhookMessageRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookMessageRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookMessageRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookMessageRead) {
                                        name = jsonFieldsNameOfWebhookMessageRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookMessageRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookMessageRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookMessageSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookMessageSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfWebhookMessageSingle = [1]string{
        0: "data",
}

// Decode decodes WebhookMessageSingle from json.
func (s *WebhookMessageSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookMessageSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookMessageSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookMessageSingle) {
                                        name = jsonFieldsNameOfWebhookMessageSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookMessageSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookMessageSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookRead) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookRead) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("type")
                e.Str(s.Type)
        }
        {
                e.FieldStart("id")
                e.Str(s.ID)
        }
        {
                e.FieldStart("attributes")
                s.Attributes.Encode(e)
        }
        {
                e.FieldStart("links")
                s.Links.Encode(e)
        }
}

var jsonFieldsNameOfWebhookRead = [4]string{
        0: "type",
        1: "id",
        2: "attributes",
        3: "links",
}

// Decode decodes WebhookRead from json.
func (s *WebhookRead) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookRead to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "type":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                v, err := d.Str()
                                s.Type = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"type\"")
                        }
                case "id":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.ID = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"id\"")
                        }
                case "attributes":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Attributes.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"attributes\"")
                        }
                case "links":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Links.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"links\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookRead")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00001111,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookRead) {
                                        name = jsonFieldsNameOfWebhookRead[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookRead) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookRead) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookResponse as json.
func (s WebhookResponse) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes WebhookResponse from json.
func (s *WebhookResponse) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookResponse to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch WebhookResponse(v) {
        case WebhookResponseTRANSACTIONS:
                *s = WebhookResponseTRANSACTIONS
        case WebhookResponseACCOUNTS:
                *s = WebhookResponseACCOUNTS
        case WebhookResponseNONE:
                *s = WebhookResponseNONE
        default:
                *s = WebhookResponse(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhookResponse) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookResponse) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookSingle) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookSingle) encodeFields(e *jx.Encoder) {
        {
                e.FieldStart("data")
                s.Data.Encode(e)
        }
}

var jsonFieldsNameOfWebhookSingle = [1]string{
        0: "data",
}

// Decode decodes WebhookSingle from json.
func (s *WebhookSingle) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookSingle to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "data":
                        requiredBitSet[0] |= 1 << 0
                        if err := func() error {
                                if err := s.Data.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"data\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookSingle")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00000001,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookSingle) {
                                        name = jsonFieldsNameOfWebhookSingle[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookSingle) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookSingle) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookStore) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookStore) encodeFields(e *jx.Encoder) {
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                e.FieldStart("title")
                e.Str(s.Title)
        }
        {
                e.FieldStart("trigger")
                s.Trigger.Encode(e)
        }
        {
                e.FieldStart("response")
                s.Response.Encode(e)
        }
        {
                e.FieldStart("delivery")
                s.Delivery.Encode(e)
        }
        {
                e.FieldStart("url")
                e.Str(s.URL)
        }
}

var jsonFieldsNameOfWebhookStore = [6]string{
        0: "active",
        1: "title",
        2: "trigger",
        3: "response",
        4: "delivery",
        5: "url",
}

// Decode decodes WebhookStore from json.
func (s *WebhookStore) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookStore to nil")
        }
        var requiredBitSet [1]uint8

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "title":
                        requiredBitSet[0] |= 1 << 1
                        if err := func() error {
                                v, err := d.Str()
                                s.Title = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "trigger":
                        requiredBitSet[0] |= 1 << 2
                        if err := func() error {
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "response":
                        requiredBitSet[0] |= 1 << 3
                        if err := func() error {
                                if err := s.Response.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"response\"")
                        }
                case "delivery":
                        requiredBitSet[0] |= 1 << 4
                        if err := func() error {
                                if err := s.Delivery.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"delivery\"")
                        }
                case "url":
                        requiredBitSet[0] |= 1 << 5
                        if err := func() error {
                                v, err := d.Str()
                                s.URL = string(v)
                                if err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"url\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookStore")
        }
        // Validate required fields.
        var failures []validate.FieldError
        for i, mask := range [1]uint8{
                0b00111110,
        } {
                if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
                        // Mask only required fields and check equality to mask using XOR.
                        //
                        // If XOR result is not zero, result is not equal to expected, so some fields are missed.
                        // Bits of fields which would be set are actually bits of missed fields.
                        missed := bits.OnesCount8(result)
                        for bitN := 0; bitN < missed; bitN++ {
                                bitIdx := bits.TrailingZeros8(result)
                                fieldIdx := i*8 + bitIdx
                                var name string
                                if fieldIdx < len(jsonFieldsNameOfWebhookStore) {
                                        name = jsonFieldsNameOfWebhookStore[fieldIdx]
                                } else {
                                        name = strconv.Itoa(fieldIdx)
                                }
                                failures = append(failures, validate.FieldError{
                                        Name:  name,
                                        Error: validate.ErrFieldRequired,
                                })
                                // Reset bit.
                                result &^= 1 << bitIdx
                        }
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookStore) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookStore) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode encodes WebhookTrigger as json.
func (s WebhookTrigger) Encode(e *jx.Encoder) {
        e.Str(string(s))
}

// Decode decodes WebhookTrigger from json.
func (s *WebhookTrigger) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookTrigger to nil")
        }
        v, err := d.StrBytes()
        if err != nil {
                return err
        }
        // Try to use constant string.
        switch WebhookTrigger(v) {
        case WebhookTriggerSTORETRANSACTION:
                *s = WebhookTriggerSTORETRANSACTION
        case WebhookTriggerUPDATETRANSACTION:
                *s = WebhookTriggerUPDATETRANSACTION
        case WebhookTriggerDESTROYTRANSACTION:
                *s = WebhookTriggerDESTROYTRANSACTION
        default:
                *s = WebhookTrigger(v)
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhookTrigger) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookTrigger) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookUpdate) Encode(e *jx.Encoder) {
        e.ObjStart()
        s.encodeFields(e)
        e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookUpdate) encodeFields(e *jx.Encoder) {
        {
                if s.Active.Set {
                        e.FieldStart("active")
                        s.Active.Encode(e)
                }
        }
        {
                if s.Title.Set {
                        e.FieldStart("title")
                        s.Title.Encode(e)
                }
        }
        {
                if s.Secret.Set {
                        e.FieldStart("secret")
                        s.Secret.Encode(e)
                }
        }
        {
                if s.Trigger.Set {
                        e.FieldStart("trigger")
                        s.Trigger.Encode(e)
                }
        }
        {
                if s.Response.Set {
                        e.FieldStart("response")
                        s.Response.Encode(e)
                }
        }
        {
                if s.Delivery.Set {
                        e.FieldStart("delivery")
                        s.Delivery.Encode(e)
                }
        }
        {
                if s.URL.Set {
                        e.FieldStart("url")
                        s.URL.Encode(e)
                }
        }
}

var jsonFieldsNameOfWebhookUpdate = [7]string{
        0: "active",
        1: "title",
        2: "secret",
        3: "trigger",
        4: "response",
        5: "delivery",
        6: "url",
}

// Decode decodes WebhookUpdate from json.
func (s *WebhookUpdate) Decode(d *jx.Decoder) error {
        if s == nil {
                return errors.New("invalid: unable to decode WebhookUpdate to nil")
        }

        if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
                switch string(k) {
                case "active":
                        if err := func() error {
                                s.Active.Reset()
                                if err := s.Active.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"active\"")
                        }
                case "title":
                        if err := func() error {
                                s.Title.Reset()
                                if err := s.Title.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"title\"")
                        }
                case "secret":
                        if err := func() error {
                                s.Secret.Reset()
                                if err := s.Secret.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"secret\"")
                        }
                case "trigger":
                        if err := func() error {
                                s.Trigger.Reset()
                                if err := s.Trigger.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"trigger\"")
                        }
                case "response":
                        if err := func() error {
                                s.Response.Reset()
                                if err := s.Response.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"response\"")
                        }
                case "delivery":
                        if err := func() error {
                                s.Delivery.Reset()
                                if err := s.Delivery.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"delivery\"")
                        }
                case "url":
                        if err := func() error {
                                s.URL.Reset()
                                if err := s.URL.Decode(d); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return errors.Wrap(err, "decode field \"url\"")
                        }
                default:
                        return d.Skip()
                }
                return nil
        }); err != nil {
                return errors.Wrap(err, "decode WebhookUpdate")
        }

        return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhookUpdate) MarshalJSON() ([]byte, error) {
        e := jx.Encoder{}
        s.Encode(&e)
        return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookUpdate) UnmarshalJSON(data []byte) error {
        d := jx.DecodeBytes(data)
        return s.Decode(d)
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "bytes"
        "net/http"

        "github.com/go-faster/jx"

        ht "github.com/ogen-go/ogen/http"
)

func encodeSetConfigurationRequest(
        req *ConfigurationUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreAccountRequest(
        req *AccountStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreAttachmentRequest(
        req *AttachmentStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreBillRequest(
        req *BillStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreBudgetRequest(
        req *BudgetStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreBudgetLimitRequest(
        req *BudgetLimitStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreCategoryRequest(
        req *Category,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreCurrencyRequest(
        req *CurrencyStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreLinkTypeRequest(
        req *LinkType,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStorePiggyBankRequest(
        req *PiggyBankStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStorePreferenceRequest(
        req *Preference,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreRecurrenceRequest(
        req *RecurrenceStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreRuleRequest(
        req *RuleStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreRuleGroupRequest(
        req *RuleGroupStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreTagRequest(
        req *TagModelStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreTransactionRequest(
        req *TransactionStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreTransactionLinkRequest(
        req *TransactionLinkStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreUserRequest(
        req *User,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeStoreWebhookRequest(
        req *WebhookStore,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateAccountRequest(
        req *AccountUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateAttachmentRequest(
        req *AttachmentUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateBillRequest(
        req *BillUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateBudgetRequest(
        req *BudgetUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateBudgetLimitRequest(
        req *BudgetLimit,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateCategoryRequest(
        req *CategoryUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateCurrencyRequest(
        req *CurrencyUpdate,
        r *http.Request,
) error {
        const contentType = "application/vnd.api+json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateLinkTypeRequest(
        req *LinkTypeUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateObjectGroupRequest(
        req *ObjectGroupUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdatePiggyBankRequest(
        req *PiggyBankUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdatePreferenceRequest(
        req *PreferenceUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateRecurrenceRequest(
        req *RecurrenceUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateRuleRequest(
        req *RuleUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateRuleGroupRequest(
        req *RuleGroupUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateTagRequest(
        req *TagModelUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateTransactionRequest(
        req *TransactionUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateTransactionLinkRequest(
        req *TransactionLinkUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateUserRequest(
        req *User,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUpdateWebhookRequest(
        req *WebhookUpdate,
        r *http.Request,
) error {
        const contentType = "application/json"
        e := jx.GetEncoder()
        {
                req.Encode(e)
        }
        encoded := e.Bytes()
        ht.SetBody(r, bytes.NewReader(encoded), contentType)
        return nil
}

func encodeUploadAttachmentRequest(
        req UploadAttachmentReq,
        r *http.Request,
) error {
        const contentType = "application/octet-stream"
        body := req
        ht.SetBody(r, body, contentType)
        return nil
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "bytes"
        "io"
        "mime"
        "net/http"

        "github.com/go-faster/errors"
        "github.com/go-faster/jx"

        "github.com/ogen-go/ogen/ogenerrors"
        "github.com/ogen-go/ogen/validate"
)

func decodeBulkUpdateTransactionsResponse(resp *http.Response) (res BulkUpdateTransactionsRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &BulkUpdateTransactionsNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDefaultCurrencyResponse(resp *http.Response) (res DefaultCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteAccountResponse(resp *http.Response) (res DeleteAccountRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteAccountNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteAttachmentResponse(resp *http.Response) (res DeleteAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteAttachmentNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteBillResponse(resp *http.Response) (res DeleteBillRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteBillNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteBudgetResponse(resp *http.Response) (res DeleteBudgetRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteBudgetNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteBudgetLimitResponse(resp *http.Response) (res DeleteBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteBudgetLimitNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteCategoryResponse(resp *http.Response) (res DeleteCategoryRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteCategoryNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteCurrencyResponse(resp *http.Response) (res DeleteCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteCurrencyNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteLinkTypeResponse(resp *http.Response) (res DeleteLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteLinkTypeNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteObjectGroupResponse(resp *http.Response) (res DeleteObjectGroupRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteObjectGroupNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeletePiggyBankResponse(resp *http.Response) (res DeletePiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeletePiggyBankNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteRecurrenceResponse(resp *http.Response) (res DeleteRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteRecurrenceNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteRuleResponse(resp *http.Response) (res DeleteRuleRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteRuleNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteRuleGroupResponse(resp *http.Response) (res DeleteRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteRuleGroupNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteTagResponse(resp *http.Response) (res DeleteTagRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteTagNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteTransactionResponse(resp *http.Response) (res DeleteTransactionRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteTransactionNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteTransactionJournalResponse(resp *http.Response) (res DeleteTransactionJournalRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteTransactionJournalNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteTransactionLinkResponse(resp *http.Response) (res DeleteTransactionLinkRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteTransactionLinkNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteUserResponse(resp *http.Response) (res DeleteUserRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteUserNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteWebhookResponse(resp *http.Response) (res DeleteWebhookRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteWebhookNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteWebhookMessageResponse(resp *http.Response) (res DeleteWebhookMessageRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteWebhookMessageNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDeleteWebhookMessageAttemptResponse(resp *http.Response) (res DeleteWebhookMessageAttemptRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DeleteWebhookMessageAttemptNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDestroyDataResponse(resp *http.Response) (res DestroyDataRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &DestroyDataNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDisableCurrencyResponse(resp *http.Response) (res DisableCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 409:
                // Code 409.
                return &DisableCurrencyConflict{}, nil
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeDownloadAttachmentResponse(resp *http.Response) (res DownloadAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := DownloadAttachmentOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeEnableCurrencyResponse(resp *http.Response) (res EnableCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportAccountsResponse(resp *http.Response) (res ExportAccountsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportAccountsOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportBillsResponse(resp *http.Response) (res ExportBillsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportBillsOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportBudgetsResponse(resp *http.Response) (res ExportBudgetsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportBudgetsOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportCategoriesResponse(resp *http.Response) (res ExportCategoriesRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportCategoriesOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportPiggiesResponse(resp *http.Response) (res ExportPiggiesRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportPiggiesOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportRecurringResponse(resp *http.Response) (res ExportRecurringRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportRecurringOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportRulesResponse(resp *http.Response) (res ExportRulesRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportRulesOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportTagsResponse(resp *http.Response) (res ExportTagsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportTagsOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeExportTransactionsResponse(resp *http.Response) (res ExportTransactionsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/octet-stream":
                        reader := resp.Body
                        b, err := io.ReadAll(reader)
                        if err != nil {
                                return res, err
                        }

                        response := ExportTransactionsOK{Data: bytes.NewReader(b)}
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeFireRuleResponse(resp *http.Response) (res FireRuleRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &FireRuleNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeFireRuleGroupResponse(resp *http.Response) (res FireRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &FireRuleGroupNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetAboutResponse(resp *http.Response) (res GetAboutRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response SystemInfo
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetAccountResponse(resp *http.Response) (res GetAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetAccountsACResponse(resp *http.Response) (res GetAccountsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteAccountArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetAttachmentResponse(resp *http.Response) (res GetAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetAvailableBudgetResponse(resp *http.Response) (res GetAvailableBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AvailableBudgetSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBasicSummaryResponse(resp *http.Response) (res GetBasicSummaryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BasicSummary
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBillResponse(resp *http.Response) (res GetBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBillsACResponse(resp *http.Response) (res GetBillsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteBillArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBudgetResponse(resp *http.Response) (res GetBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBudgetLimitResponse(resp *http.Response) (res GetBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetBudgetsACResponse(resp *http.Response) (res GetBudgetsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteBudgetArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCategoriesACResponse(resp *http.Response) (res GetCategoriesACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteCategoryArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCategoryResponse(resp *http.Response) (res GetCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CategorySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetChartAccountOverviewResponse(resp *http.Response) (res GetChartAccountOverviewRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ChartLine
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetConfigurationResponse(resp *http.Response) (res GetConfigurationRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ConfigurationArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCronResponse(resp *http.Response) (res GetCronRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CronResult
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCurrenciesACResponse(resp *http.Response) (res GetCurrenciesACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteCurrencyArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCurrenciesCodeACResponse(resp *http.Response) (res GetCurrenciesCodeACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteCurrencyCodeArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCurrencyResponse(resp *http.Response) (res GetCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetCurrentUserResponse(resp *http.Response) (res GetCurrentUserRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response UserSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetDefaultCurrencyResponse(resp *http.Response) (res GetDefaultCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetLinkTypeResponse(resp *http.Response) (res GetLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response LinkTypeSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetObjectGroupResponse(resp *http.Response) (res GetObjectGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ObjectGroupSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetObjectGroupsACResponse(resp *http.Response) (res GetObjectGroupsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteObjectGroupArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetPiggiesACResponse(resp *http.Response) (res GetPiggiesACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompletePiggyArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetPiggiesBalanceACResponse(resp *http.Response) (res GetPiggiesBalanceACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompletePiggyBalanceArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetPiggyBankResponse(resp *http.Response) (res GetPiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetPreferenceResponse(resp *http.Response) (res GetPreferenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PreferenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRecurrenceResponse(resp *http.Response) (res GetRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RecurrenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRecurringACResponse(resp *http.Response) (res GetRecurringACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteRecurrenceArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRuleResponse(resp *http.Response) (res GetRuleRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRuleGroupResponse(resp *http.Response) (res GetRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleGroupSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRuleGroupsACResponse(resp *http.Response) (res GetRuleGroupsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteRuleGroupArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetRulesACResponse(resp *http.Response) (res GetRulesACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteRuleArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetSingleConfigurationResponse(resp *http.Response) (res GetSingleConfigurationRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ConfigurationSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetSingleWebhookMessageResponse(resp *http.Response) (res GetSingleWebhookMessageRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookMessageSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetSingleWebhookMessageAttemptResponse(resp *http.Response) (res GetSingleWebhookMessageAttemptRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookAttemptSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTagResponse(resp *http.Response) (res GetTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TagSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTagACResponse(resp *http.Response) (res GetTagACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteTagArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionResponse(resp *http.Response) (res GetTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionByJournalResponse(resp *http.Response) (res GetTransactionByJournalRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionLinkResponse(resp *http.Response) (res GetTransactionLinkRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionLinkSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionTypesACResponse(resp *http.Response) (res GetTransactionTypesACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteTransactionTypeArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionsACResponse(resp *http.Response) (res GetTransactionsACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteTransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetTransactionsIDACResponse(resp *http.Response) (res GetTransactionsIDACRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AutocompleteTransactionIDArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetUserResponse(resp *http.Response) (res GetUserRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response UserSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetWebhookResponse(resp *http.Response) (res GetWebhookRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetWebhookMessageAttemptsResponse(resp *http.Response) (res GetWebhookMessageAttemptsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookAttemptArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeGetWebhookMessagesResponse(resp *http.Response) (res GetWebhookMessagesRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookMessageArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseAssetResponse(resp *http.Response) (res InsightExpenseAssetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseBillResponse(resp *http.Response) (res InsightExpenseBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseBudgetResponse(resp *http.Response) (res InsightExpenseBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseCategoryResponse(resp *http.Response) (res InsightExpenseCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseExpenseResponse(resp *http.Response) (res InsightExpenseExpenseRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseNoBillResponse(resp *http.Response) (res InsightExpenseNoBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseNoBudgetResponse(resp *http.Response) (res InsightExpenseNoBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseNoCategoryResponse(resp *http.Response) (res InsightExpenseNoCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseNoTagResponse(resp *http.Response) (res InsightExpenseNoTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseTagResponse(resp *http.Response) (res InsightExpenseTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightExpenseTotalResponse(resp *http.Response) (res InsightExpenseTotalRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeAssetResponse(resp *http.Response) (res InsightIncomeAssetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeCategoryResponse(resp *http.Response) (res InsightIncomeCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeNoCategoryResponse(resp *http.Response) (res InsightIncomeNoCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeNoTagResponse(resp *http.Response) (res InsightIncomeNoTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeRevenueResponse(resp *http.Response) (res InsightIncomeRevenueRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeTagResponse(resp *http.Response) (res InsightIncomeTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightIncomeTotalResponse(resp *http.Response) (res InsightIncomeTotalRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransferCategoryResponse(resp *http.Response) (res InsightTransferCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransferNoCategoryResponse(resp *http.Response) (res InsightTransferNoCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransferNoTagResponse(resp *http.Response) (res InsightTransferNoTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransferTagResponse(resp *http.Response) (res InsightTransferTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightGroup
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransferTotalResponse(resp *http.Response) (res InsightTransferTotalRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTotal
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeInsightTransfersResponse(resp *http.Response) (res InsightTransfersRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InsightTransfer
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAccountResponse(resp *http.Response) (res ListAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAccountByCurrencyResponse(resp *http.Response) (res ListAccountByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentResponse(resp *http.Response) (res ListAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByAccountResponse(resp *http.Response) (res ListAttachmentByAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByBillResponse(resp *http.Response) (res ListAttachmentByBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByBudgetResponse(resp *http.Response) (res ListAttachmentByBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByCategoryResponse(resp *http.Response) (res ListAttachmentByCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByPiggyBankResponse(resp *http.Response) (res ListAttachmentByPiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByTagResponse(resp *http.Response) (res ListAttachmentByTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAttachmentByTransactionResponse(resp *http.Response) (res ListAttachmentByTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAvailableBudgetResponse(resp *http.Response) (res ListAvailableBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AvailableBudgetArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListAvailableBudgetByCurrencyResponse(resp *http.Response) (res ListAvailableBudgetByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AvailableBudgetArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBillResponse(resp *http.Response) (res ListBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBillByCurrencyResponse(resp *http.Response) (res ListBillByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBillByObjectGroupResponse(resp *http.Response) (res ListBillByObjectGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBudgetResponse(resp *http.Response) (res ListBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBudgetLimitResponse(resp *http.Response) (res ListBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBudgetLimitByBudgetResponse(resp *http.Response) (res ListBudgetLimitByBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListBudgetLimitByCurrencyResponse(resp *http.Response) (res ListBudgetLimitByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListCategoryResponse(resp *http.Response) (res ListCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CategoryArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListCurrencyResponse(resp *http.Response) (res ListCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencyArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListEventByPiggyBankResponse(resp *http.Response) (res ListEventByPiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankEventArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListEventByTransactionResponse(resp *http.Response) (res ListEventByTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankEventArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListLinkTypeResponse(resp *http.Response) (res ListLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response LinkTypeArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListLinksByJournalResponse(resp *http.Response) (res ListLinksByJournalRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionLinkArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListObjectGroupsResponse(resp *http.Response) (res ListObjectGroupsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ObjectGroupArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListPiggyBankResponse(resp *http.Response) (res ListPiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListPiggyBankByAccountResponse(resp *http.Response) (res ListPiggyBankByAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListPiggyBankByObjectGroupResponse(resp *http.Response) (res ListPiggyBankByObjectGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListPreferenceResponse(resp *http.Response) (res ListPreferenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PreferenceArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRecurrenceResponse(resp *http.Response) (res ListRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RecurrenceArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRecurrenceByCurrencyResponse(resp *http.Response) (res ListRecurrenceByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RecurrenceArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRuleResponse(resp *http.Response) (res ListRuleRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRuleByBillResponse(resp *http.Response) (res ListRuleByBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRuleByCurrencyResponse(resp *http.Response) (res ListRuleByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRuleByGroupResponse(resp *http.Response) (res ListRuleByGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListRuleGroupResponse(resp *http.Response) (res ListRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleGroupArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTagResponse(resp *http.Response) (res ListTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TagArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionResponse(resp *http.Response) (res ListTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByAccountResponse(resp *http.Response) (res ListTransactionByAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByBillResponse(resp *http.Response) (res ListTransactionByBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByBudgetResponse(resp *http.Response) (res ListTransactionByBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByBudgetLimitResponse(resp *http.Response) (res ListTransactionByBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByCategoryResponse(resp *http.Response) (res ListTransactionByCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByCurrencyResponse(resp *http.Response) (res ListTransactionByCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByLinkTypeResponse(resp *http.Response) (res ListTransactionByLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByRecurrenceResponse(resp *http.Response) (res ListTransactionByRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionByTagResponse(resp *http.Response) (res ListTransactionByTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListTransactionLinkResponse(resp *http.Response) (res ListTransactionLinkRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionLinkArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListUserResponse(resp *http.Response) (res ListUserRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response UserArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeListWebhookResponse(resp *http.Response) (res ListWebhookRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodePurgeDataResponse(resp *http.Response) (res PurgeDataRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &PurgeDataNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeSearchAccountsResponse(resp *http.Response) (res SearchAccountsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeSearchTransactionsResponse(resp *http.Response) (res SearchTransactionsRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeSetConfigurationResponse(resp *http.Response) (res SetConfigurationRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ConfigurationSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreAccountResponse(resp *http.Response) (res StoreAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreAttachmentResponse(resp *http.Response) (res StoreAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreBillResponse(resp *http.Response) (res StoreBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreBudgetResponse(resp *http.Response) (res StoreBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreBudgetLimitResponse(resp *http.Response) (res StoreBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreCategoryResponse(resp *http.Response) (res StoreCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CategorySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreCurrencyResponse(resp *http.Response) (res StoreCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreLinkTypeResponse(resp *http.Response) (res StoreLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response LinkTypeSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStorePiggyBankResponse(resp *http.Response) (res StorePiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStorePreferenceResponse(resp *http.Response) (res StorePreferenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PreferenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreRecurrenceResponse(resp *http.Response) (res StoreRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RecurrenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreRuleResponse(resp *http.Response) (res StoreRuleRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreRuleGroupResponse(resp *http.Response) (res StoreRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleGroupSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreTagResponse(resp *http.Response) (res StoreTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TagSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreTransactionResponse(resp *http.Response) (res StoreTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreTransactionLinkResponse(resp *http.Response) (res StoreTransactionLinkRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionLinkSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreUserResponse(resp *http.Response) (res StoreUserRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response UserSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeStoreWebhookResponse(resp *http.Response) (res StoreWebhookRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeSubmitWebookResponse(resp *http.Response) (res SubmitWebookRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                return &SubmitWebookOK{}, nil
        case 204:
                // Code 204.
                return &SubmitWebookNoContent{}, nil
        case 404:
                // Code 404.
                return &SubmitWebookNotFound{}, nil
        case 500:
                // Code 500.
                return &SubmitWebookInternalServerError{}, nil
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeTestRuleResponse(resp *http.Response) (res TestRuleRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeTestRuleGroupResponse(resp *http.Response) (res TestRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionArray
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateAccountResponse(resp *http.Response) (res UpdateAccountRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AccountSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateAttachmentResponse(resp *http.Response) (res UpdateAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response AttachmentSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateBillResponse(resp *http.Response) (res UpdateBillRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BillSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateBudgetResponse(resp *http.Response) (res UpdateBudgetRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateBudgetLimitResponse(resp *http.Response) (res UpdateBudgetLimitRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BudgetLimitSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateCategoryResponse(resp *http.Response) (res UpdateCategoryRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CategorySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateCurrencyResponse(resp *http.Response) (res UpdateCurrencyRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response CurrencySingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateLinkTypeResponse(resp *http.Response) (res UpdateLinkTypeRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response LinkTypeSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateObjectGroupResponse(resp *http.Response) (res UpdateObjectGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ObjectGroupSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdatePiggyBankResponse(resp *http.Response) (res UpdatePiggyBankRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PiggyBankSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdatePreferenceResponse(resp *http.Response) (res UpdatePreferenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response PreferenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateRecurrenceResponse(resp *http.Response) (res UpdateRecurrenceRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RecurrenceSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateRuleResponse(resp *http.Response) (res UpdateRuleRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateRuleGroupResponse(resp *http.Response) (res UpdateRuleGroupRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response RuleGroupSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateTagResponse(resp *http.Response) (res UpdateTagRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TagSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateTransactionResponse(resp *http.Response) (res UpdateTransactionRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateTransactionLinkResponse(resp *http.Response) (res UpdateTransactionLinkRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response TransactionLinkSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateUserResponse(resp *http.Response) (res UpdateUserRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response UserSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUpdateWebhookResponse(resp *http.Response) (res UpdateWebhookRes, _ error) {
        switch resp.StatusCode {
        case 200:
                // Code 200.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/vnd.api+json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response WebhookSingle
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

func decodeUploadAttachmentResponse(resp *http.Response) (res UploadAttachmentRes, _ error) {
        switch resp.StatusCode {
        case 204:
                // Code 204.
                return &UploadAttachmentNoContent{}, nil
        case 400:
                // Code 400.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response BadRequest
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 401:
                // Code 401.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response Unauthenticated
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 404:
                // Code 404.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response NotFound
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 422:
                // Code 422.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response ValidationError
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        case 500:
                // Code 500.
                ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
                if err != nil {
                        return res, errors.Wrap(err, "parse media type")
                }
                switch {
                case ct == "application/json":
                        buf, err := io.ReadAll(resp.Body)
                        if err != nil {
                                return res, err
                        }
                        d := jx.DecodeBytes(buf)

                        var response InternalException
                        if err := func() error {
                                if err := response.Decode(d); err != nil {
                                        return err
                                }
                                if err := d.Skip(); err != io.EOF {
                                        return errors.New("unexpected trailing data")
                                }
                                return nil
                        }(); err != nil {
                                err = &ogenerrors.DecodeBodyError{
                                        ContentType: ct,
                                        Body:        buf,
                                        Err:         err,
                                }
                                return res, err
                        }
                        return &response, nil
                default:
                        return res, validate.InvalidContentType(ct)
                }
        }
        return res, validate.UnexpectedStatusCode(resp.StatusCode)
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "io"
        "net/url"
        "time"

        "github.com/go-faster/errors"
        "github.com/google/uuid"
)

// Ref: #/components/schemas/Account
type Account struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // If omitted, defaults to true.
        Active OptBool `json:"active"`
        // Order of the account. Is NULL if account is not asset or liability.
        Order       OptNilInt32               `json:"order"`
        Name        string                    `json:"name"`
        Type        ShortAccountTypeProperty  `json:"type"`
        AccountRole OptNilAccountRoleProperty `json:"account_role"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyCode          OptString `json:"currency_code"`
        CurrencySymbol        OptString `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        CurrentBalance        OptString `json:"current_balance"`
        // The timestamp for this date is always 23:59:59, to indicate it's the balance at the very END of
        // that particular day.
        CurrentBalanceDate OptDateTime  `json:"current_balance_date"`
        Iban               OptNilString `json:"iban"`
        Bic                OptNilString `json:"bic"`
        AccountNumber      OptNilString `json:"account_number"`
        // Represents the opening balance, the initial amount this account holds.
        OpeningBalance OptString `json:"opening_balance"`
        // Represents the current debt for liabilities.
        CurrentDebt OptNilString `json:"current_debt"`
        // Represents the date of the opening balance.
        OpeningBalanceDate OptNilDateTime `json:"opening_balance_date"`
        VirtualBalance     OptString      `json:"virtual_balance"`
        // If omitted, defaults to true.
        IncludeNetWorth OptBool              `json:"include_net_worth"`
        CreditCardType  OptNilCreditCardType `json:"credit_card_type"`
        // Mandatory when the account_role is ccAsset. Moment at which CC payment installments are asked for
        // by the bank.
        MonthlyPaymentDate OptNilDateTime           `json:"monthly_payment_date"`
        LiabilityType      OptNilLiabilityType      `json:"liability_type"`
        LiabilityDirection OptNilLiabilityDirection `json:"liability_direction"`
        // Mandatory when type is liability. Interest percentage.
        Interest       OptNilString         `json:"interest"`
        InterestPeriod OptNilInterestPeriod `json:"interest_period"`
        Notes          OptNilString         `json:"notes"`
        // Latitude of the accounts's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the accounts's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Account) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Account) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetActive returns the value of Active.
func (s *Account) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *Account) GetOrder() OptNilInt32 {
        return s.Order
}

// GetName returns the value of Name.
func (s *Account) GetName() string {
        return s.Name
}

// GetType returns the value of Type.
func (s *Account) GetType() ShortAccountTypeProperty {
        return s.Type
}

// GetAccountRole returns the value of AccountRole.
func (s *Account) GetAccountRole() OptNilAccountRoleProperty {
        return s.AccountRole
}

// GetCurrencyID returns the value of CurrencyID.
func (s *Account) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *Account) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *Account) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *Account) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetCurrentBalance returns the value of CurrentBalance.
func (s *Account) GetCurrentBalance() OptString {
        return s.CurrentBalance
}

// GetCurrentBalanceDate returns the value of CurrentBalanceDate.
func (s *Account) GetCurrentBalanceDate() OptDateTime {
        return s.CurrentBalanceDate
}

// GetIban returns the value of Iban.
func (s *Account) GetIban() OptNilString {
        return s.Iban
}

// GetBic returns the value of Bic.
func (s *Account) GetBic() OptNilString {
        return s.Bic
}

// GetAccountNumber returns the value of AccountNumber.
func (s *Account) GetAccountNumber() OptNilString {
        return s.AccountNumber
}

// GetOpeningBalance returns the value of OpeningBalance.
func (s *Account) GetOpeningBalance() OptString {
        return s.OpeningBalance
}

// GetCurrentDebt returns the value of CurrentDebt.
func (s *Account) GetCurrentDebt() OptNilString {
        return s.CurrentDebt
}

// GetOpeningBalanceDate returns the value of OpeningBalanceDate.
func (s *Account) GetOpeningBalanceDate() OptNilDateTime {
        return s.OpeningBalanceDate
}

// GetVirtualBalance returns the value of VirtualBalance.
func (s *Account) GetVirtualBalance() OptString {
        return s.VirtualBalance
}

// GetIncludeNetWorth returns the value of IncludeNetWorth.
func (s *Account) GetIncludeNetWorth() OptBool {
        return s.IncludeNetWorth
}

// GetCreditCardType returns the value of CreditCardType.
func (s *Account) GetCreditCardType() OptNilCreditCardType {
        return s.CreditCardType
}

// GetMonthlyPaymentDate returns the value of MonthlyPaymentDate.
func (s *Account) GetMonthlyPaymentDate() OptNilDateTime {
        return s.MonthlyPaymentDate
}

// GetLiabilityType returns the value of LiabilityType.
func (s *Account) GetLiabilityType() OptNilLiabilityType {
        return s.LiabilityType
}

// GetLiabilityDirection returns the value of LiabilityDirection.
func (s *Account) GetLiabilityDirection() OptNilLiabilityDirection {
        return s.LiabilityDirection
}

// GetInterest returns the value of Interest.
func (s *Account) GetInterest() OptNilString {
        return s.Interest
}

// GetInterestPeriod returns the value of InterestPeriod.
func (s *Account) GetInterestPeriod() OptNilInterestPeriod {
        return s.InterestPeriod
}

// GetNotes returns the value of Notes.
func (s *Account) GetNotes() OptNilString {
        return s.Notes
}

// GetLatitude returns the value of Latitude.
func (s *Account) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *Account) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *Account) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Account) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Account) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetActive sets the value of Active.
func (s *Account) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *Account) SetOrder(val OptNilInt32) {
        s.Order = val
}

// SetName sets the value of Name.
func (s *Account) SetName(val string) {
        s.Name = val
}

// SetType sets the value of Type.
func (s *Account) SetType(val ShortAccountTypeProperty) {
        s.Type = val
}

// SetAccountRole sets the value of AccountRole.
func (s *Account) SetAccountRole(val OptNilAccountRoleProperty) {
        s.AccountRole = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *Account) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *Account) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *Account) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *Account) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetCurrentBalance sets the value of CurrentBalance.
func (s *Account) SetCurrentBalance(val OptString) {
        s.CurrentBalance = val
}

// SetCurrentBalanceDate sets the value of CurrentBalanceDate.
func (s *Account) SetCurrentBalanceDate(val OptDateTime) {
        s.CurrentBalanceDate = val
}

// SetIban sets the value of Iban.
func (s *Account) SetIban(val OptNilString) {
        s.Iban = val
}

// SetBic sets the value of Bic.
func (s *Account) SetBic(val OptNilString) {
        s.Bic = val
}

// SetAccountNumber sets the value of AccountNumber.
func (s *Account) SetAccountNumber(val OptNilString) {
        s.AccountNumber = val
}

// SetOpeningBalance sets the value of OpeningBalance.
func (s *Account) SetOpeningBalance(val OptString) {
        s.OpeningBalance = val
}

// SetCurrentDebt sets the value of CurrentDebt.
func (s *Account) SetCurrentDebt(val OptNilString) {
        s.CurrentDebt = val
}

// SetOpeningBalanceDate sets the value of OpeningBalanceDate.
func (s *Account) SetOpeningBalanceDate(val OptNilDateTime) {
        s.OpeningBalanceDate = val
}

// SetVirtualBalance sets the value of VirtualBalance.
func (s *Account) SetVirtualBalance(val OptString) {
        s.VirtualBalance = val
}

// SetIncludeNetWorth sets the value of IncludeNetWorth.
func (s *Account) SetIncludeNetWorth(val OptBool) {
        s.IncludeNetWorth = val
}

// SetCreditCardType sets the value of CreditCardType.
func (s *Account) SetCreditCardType(val OptNilCreditCardType) {
        s.CreditCardType = val
}

// SetMonthlyPaymentDate sets the value of MonthlyPaymentDate.
func (s *Account) SetMonthlyPaymentDate(val OptNilDateTime) {
        s.MonthlyPaymentDate = val
}

// SetLiabilityType sets the value of LiabilityType.
func (s *Account) SetLiabilityType(val OptNilLiabilityType) {
        s.LiabilityType = val
}

// SetLiabilityDirection sets the value of LiabilityDirection.
func (s *Account) SetLiabilityDirection(val OptNilLiabilityDirection) {
        s.LiabilityDirection = val
}

// SetInterest sets the value of Interest.
func (s *Account) SetInterest(val OptNilString) {
        s.Interest = val
}

// SetInterestPeriod sets the value of InterestPeriod.
func (s *Account) SetInterestPeriod(val OptNilInterestPeriod) {
        s.InterestPeriod = val
}

// SetNotes sets the value of Notes.
func (s *Account) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetLatitude sets the value of Latitude.
func (s *Account) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *Account) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *Account) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// Ref: #/components/schemas/AccountArray
type AccountArray struct {
        Data []AccountRead `json:"data"`
        Meta Meta          `json:"meta"`
}

// GetData returns the value of Data.
func (s *AccountArray) GetData() []AccountRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *AccountArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *AccountArray) SetData(val []AccountRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *AccountArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*AccountArray) listAccountByCurrencyRes() {}
func (*AccountArray) listAccountRes()           {}
func (*AccountArray) searchAccountsRes()        {}

// Ref: #/components/schemas/AccountRead
type AccountRead struct {
        // Immutable value.
        Type       string  `json:"type"`
        ID         string  `json:"id"`
        Attributes Account `json:"attributes"`
}

// GetType returns the value of Type.
func (s *AccountRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *AccountRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *AccountRead) GetAttributes() Account {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *AccountRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *AccountRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *AccountRead) SetAttributes(val Account) {
        s.Attributes = val
}

// Is only mandatory when the type is asset.
// Ref: #/components/schemas/AccountRoleProperty
type AccountRoleProperty string

const (
        AccountRolePropertyDefaultAsset    AccountRoleProperty = "defaultAsset"
        AccountRolePropertySharedAsset     AccountRoleProperty = "sharedAsset"
        AccountRolePropertySavingAsset     AccountRoleProperty = "savingAsset"
        AccountRolePropertyCcAsset         AccountRoleProperty = "ccAsset"
        AccountRolePropertyCashWalletAsset AccountRoleProperty = "cashWalletAsset"
)

// AllValues returns all AccountRoleProperty values.
func (AccountRoleProperty) AllValues() []AccountRoleProperty {
        return []AccountRoleProperty{
                AccountRolePropertyDefaultAsset,
                AccountRolePropertySharedAsset,
                AccountRolePropertySavingAsset,
                AccountRolePropertyCcAsset,
                AccountRolePropertyCashWalletAsset,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AccountRoleProperty) MarshalText() ([]byte, error) {
        switch s {
        case AccountRolePropertyDefaultAsset:
                return []byte(s), nil
        case AccountRolePropertySharedAsset:
                return []byte(s), nil
        case AccountRolePropertySavingAsset:
                return []byte(s), nil
        case AccountRolePropertyCcAsset:
                return []byte(s), nil
        case AccountRolePropertyCashWalletAsset:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AccountRoleProperty) UnmarshalText(data []byte) error {
        switch AccountRoleProperty(data) {
        case AccountRolePropertyDefaultAsset:
                *s = AccountRolePropertyDefaultAsset
                return nil
        case AccountRolePropertySharedAsset:
                *s = AccountRolePropertySharedAsset
                return nil
        case AccountRolePropertySavingAsset:
                *s = AccountRolePropertySavingAsset
                return nil
        case AccountRolePropertyCcAsset:
                *s = AccountRolePropertyCcAsset
                return nil
        case AccountRolePropertyCashWalletAsset:
                *s = AccountRolePropertyCashWalletAsset
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/AccountSearchFieldFilter
type AccountSearchFieldFilter string

const (
        AccountSearchFieldFilterAll    AccountSearchFieldFilter = "all"
        AccountSearchFieldFilterIban   AccountSearchFieldFilter = "iban"
        AccountSearchFieldFilterName   AccountSearchFieldFilter = "name"
        AccountSearchFieldFilterNumber AccountSearchFieldFilter = "number"
        AccountSearchFieldFilterID     AccountSearchFieldFilter = "id"
)

// AllValues returns all AccountSearchFieldFilter values.
func (AccountSearchFieldFilter) AllValues() []AccountSearchFieldFilter {
        return []AccountSearchFieldFilter{
                AccountSearchFieldFilterAll,
                AccountSearchFieldFilterIban,
                AccountSearchFieldFilterName,
                AccountSearchFieldFilterNumber,
                AccountSearchFieldFilterID,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AccountSearchFieldFilter) MarshalText() ([]byte, error) {
        switch s {
        case AccountSearchFieldFilterAll:
                return []byte(s), nil
        case AccountSearchFieldFilterIban:
                return []byte(s), nil
        case AccountSearchFieldFilterName:
                return []byte(s), nil
        case AccountSearchFieldFilterNumber:
                return []byte(s), nil
        case AccountSearchFieldFilterID:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AccountSearchFieldFilter) UnmarshalText(data []byte) error {
        switch AccountSearchFieldFilter(data) {
        case AccountSearchFieldFilterAll:
                *s = AccountSearchFieldFilterAll
                return nil
        case AccountSearchFieldFilterIban:
                *s = AccountSearchFieldFilterIban
                return nil
        case AccountSearchFieldFilterName:
                *s = AccountSearchFieldFilterName
                return nil
        case AccountSearchFieldFilterNumber:
                *s = AccountSearchFieldFilterNumber
                return nil
        case AccountSearchFieldFilterID:
                *s = AccountSearchFieldFilterID
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/AccountSingle
type AccountSingle struct {
        Data AccountRead `json:"data"`
}

// GetData returns the value of Data.
func (s *AccountSingle) GetData() AccountRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *AccountSingle) SetData(val AccountRead) {
        s.Data = val
}

func (*AccountSingle) getAccountRes()    {}
func (*AccountSingle) storeAccountRes()  {}
func (*AccountSingle) updateAccountRes() {}

// Ref: #/components/schemas/AccountStore
type AccountStore struct {
        Name          string                   `json:"name"`
        Type          ShortAccountTypeProperty `json:"type"`
        Iban          OptNilString             `json:"iban"`
        Bic           OptNilString             `json:"bic"`
        AccountNumber OptNilString             `json:"account_number"`
        // Represents the opening balance, the initial amount this account holds.
        OpeningBalance OptString `json:"opening_balance"`
        // Represents the date of the opening balance.
        OpeningBalanceDate OptNilDateTime `json:"opening_balance_date"`
        VirtualBalance     OptString      `json:"virtual_balance"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyCode OptString `json:"currency_code"`
        // If omitted, defaults to true.
        Active OptBool `json:"active"`
        // Order of the account.
        Order OptInt32 `json:"order"`
        // If omitted, defaults to true.
        IncludeNetWorth OptBool                   `json:"include_net_worth"`
        AccountRole     OptNilAccountRoleProperty `json:"account_role"`
        CreditCardType  OptNilCreditCardType      `json:"credit_card_type"`
        // Mandatory when the account_role is ccAsset. Moment at which CC payment installments are asked for
        // by the bank.
        MonthlyPaymentDate OptNilDateTime           `json:"monthly_payment_date"`
        LiabilityType      OptNilLiabilityType      `json:"liability_type"`
        LiabilityDirection OptNilLiabilityDirection `json:"liability_direction"`
        // Mandatory when type is liability. Interest percentage.
        Interest       OptNilString         `json:"interest"`
        InterestPeriod OptNilInterestPeriod `json:"interest_period"`
        Notes          OptNilString         `json:"notes"`
        // Latitude of the accounts's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the accounts's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetName returns the value of Name.
func (s *AccountStore) GetName() string {
        return s.Name
}

// GetType returns the value of Type.
func (s *AccountStore) GetType() ShortAccountTypeProperty {
        return s.Type
}

// GetIban returns the value of Iban.
func (s *AccountStore) GetIban() OptNilString {
        return s.Iban
}

// GetBic returns the value of Bic.
func (s *AccountStore) GetBic() OptNilString {
        return s.Bic
}

// GetAccountNumber returns the value of AccountNumber.
func (s *AccountStore) GetAccountNumber() OptNilString {
        return s.AccountNumber
}

// GetOpeningBalance returns the value of OpeningBalance.
func (s *AccountStore) GetOpeningBalance() OptString {
        return s.OpeningBalance
}

// GetOpeningBalanceDate returns the value of OpeningBalanceDate.
func (s *AccountStore) GetOpeningBalanceDate() OptNilDateTime {
        return s.OpeningBalanceDate
}

// GetVirtualBalance returns the value of VirtualBalance.
func (s *AccountStore) GetVirtualBalance() OptString {
        return s.VirtualBalance
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AccountStore) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AccountStore) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetActive returns the value of Active.
func (s *AccountStore) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *AccountStore) GetOrder() OptInt32 {
        return s.Order
}

// GetIncludeNetWorth returns the value of IncludeNetWorth.
func (s *AccountStore) GetIncludeNetWorth() OptBool {
        return s.IncludeNetWorth
}

// GetAccountRole returns the value of AccountRole.
func (s *AccountStore) GetAccountRole() OptNilAccountRoleProperty {
        return s.AccountRole
}

// GetCreditCardType returns the value of CreditCardType.
func (s *AccountStore) GetCreditCardType() OptNilCreditCardType {
        return s.CreditCardType
}

// GetMonthlyPaymentDate returns the value of MonthlyPaymentDate.
func (s *AccountStore) GetMonthlyPaymentDate() OptNilDateTime {
        return s.MonthlyPaymentDate
}

// GetLiabilityType returns the value of LiabilityType.
func (s *AccountStore) GetLiabilityType() OptNilLiabilityType {
        return s.LiabilityType
}

// GetLiabilityDirection returns the value of LiabilityDirection.
func (s *AccountStore) GetLiabilityDirection() OptNilLiabilityDirection {
        return s.LiabilityDirection
}

// GetInterest returns the value of Interest.
func (s *AccountStore) GetInterest() OptNilString {
        return s.Interest
}

// GetInterestPeriod returns the value of InterestPeriod.
func (s *AccountStore) GetInterestPeriod() OptNilInterestPeriod {
        return s.InterestPeriod
}

// GetNotes returns the value of Notes.
func (s *AccountStore) GetNotes() OptNilString {
        return s.Notes
}

// GetLatitude returns the value of Latitude.
func (s *AccountStore) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *AccountStore) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *AccountStore) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetName sets the value of Name.
func (s *AccountStore) SetName(val string) {
        s.Name = val
}

// SetType sets the value of Type.
func (s *AccountStore) SetType(val ShortAccountTypeProperty) {
        s.Type = val
}

// SetIban sets the value of Iban.
func (s *AccountStore) SetIban(val OptNilString) {
        s.Iban = val
}

// SetBic sets the value of Bic.
func (s *AccountStore) SetBic(val OptNilString) {
        s.Bic = val
}

// SetAccountNumber sets the value of AccountNumber.
func (s *AccountStore) SetAccountNumber(val OptNilString) {
        s.AccountNumber = val
}

// SetOpeningBalance sets the value of OpeningBalance.
func (s *AccountStore) SetOpeningBalance(val OptString) {
        s.OpeningBalance = val
}

// SetOpeningBalanceDate sets the value of OpeningBalanceDate.
func (s *AccountStore) SetOpeningBalanceDate(val OptNilDateTime) {
        s.OpeningBalanceDate = val
}

// SetVirtualBalance sets the value of VirtualBalance.
func (s *AccountStore) SetVirtualBalance(val OptString) {
        s.VirtualBalance = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AccountStore) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AccountStore) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetActive sets the value of Active.
func (s *AccountStore) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *AccountStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetIncludeNetWorth sets the value of IncludeNetWorth.
func (s *AccountStore) SetIncludeNetWorth(val OptBool) {
        s.IncludeNetWorth = val
}

// SetAccountRole sets the value of AccountRole.
func (s *AccountStore) SetAccountRole(val OptNilAccountRoleProperty) {
        s.AccountRole = val
}

// SetCreditCardType sets the value of CreditCardType.
func (s *AccountStore) SetCreditCardType(val OptNilCreditCardType) {
        s.CreditCardType = val
}

// SetMonthlyPaymentDate sets the value of MonthlyPaymentDate.
func (s *AccountStore) SetMonthlyPaymentDate(val OptNilDateTime) {
        s.MonthlyPaymentDate = val
}

// SetLiabilityType sets the value of LiabilityType.
func (s *AccountStore) SetLiabilityType(val OptNilLiabilityType) {
        s.LiabilityType = val
}

// SetLiabilityDirection sets the value of LiabilityDirection.
func (s *AccountStore) SetLiabilityDirection(val OptNilLiabilityDirection) {
        s.LiabilityDirection = val
}

// SetInterest sets the value of Interest.
func (s *AccountStore) SetInterest(val OptNilString) {
        s.Interest = val
}

// SetInterestPeriod sets the value of InterestPeriod.
func (s *AccountStore) SetInterestPeriod(val OptNilInterestPeriod) {
        s.InterestPeriod = val
}

// SetNotes sets the value of Notes.
func (s *AccountStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetLatitude sets the value of Latitude.
func (s *AccountStore) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *AccountStore) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *AccountStore) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// Ref: #/components/schemas/AccountTypeFilter
type AccountTypeFilter string

const (
        AccountTypeFilterAll                   AccountTypeFilter = "all"
        AccountTypeFilterAsset                 AccountTypeFilter = "asset"
        AccountTypeFilterCash                  AccountTypeFilter = "cash"
        AccountTypeFilterExpense               AccountTypeFilter = "expense"
        AccountTypeFilterRevenue               AccountTypeFilter = "revenue"
        AccountTypeFilterSpecial               AccountTypeFilter = "special"
        AccountTypeFilterHidden                AccountTypeFilter = "hidden"
        AccountTypeFilterLiability             AccountTypeFilter = "liability"
        AccountTypeFilterLiabilities           AccountTypeFilter = "liabilities"
        AccountTypeFilterDefaultAccount        AccountTypeFilter = "Default account"
        AccountTypeFilterCashAccount           AccountTypeFilter = "Cash account"
        AccountTypeFilterAssetAccount          AccountTypeFilter = "Asset account"
        AccountTypeFilterExpenseAccount        AccountTypeFilter = "Expense account"
        AccountTypeFilterRevenueAccount        AccountTypeFilter = "Revenue account"
        AccountTypeFilterInitialBalanceAccount AccountTypeFilter = "Initial balance account"
        AccountTypeFilterBeneficiaryAccount    AccountTypeFilter = "Beneficiary account"
        AccountTypeFilterImportAccount         AccountTypeFilter = "Import account"
        AccountTypeFilterReconciliationAccount AccountTypeFilter = "Reconciliation account"
        AccountTypeFilterLoan                  AccountTypeFilter = "Loan"
        AccountTypeFilterDebt                  AccountTypeFilter = "Debt"
        AccountTypeFilterMortgage              AccountTypeFilter = "Mortgage"
)

// AllValues returns all AccountTypeFilter values.
func (AccountTypeFilter) AllValues() []AccountTypeFilter {
        return []AccountTypeFilter{
                AccountTypeFilterAll,
                AccountTypeFilterAsset,
                AccountTypeFilterCash,
                AccountTypeFilterExpense,
                AccountTypeFilterRevenue,
                AccountTypeFilterSpecial,
                AccountTypeFilterHidden,
                AccountTypeFilterLiability,
                AccountTypeFilterLiabilities,
                AccountTypeFilterDefaultAccount,
                AccountTypeFilterCashAccount,
                AccountTypeFilterAssetAccount,
                AccountTypeFilterExpenseAccount,
                AccountTypeFilterRevenueAccount,
                AccountTypeFilterInitialBalanceAccount,
                AccountTypeFilterBeneficiaryAccount,
                AccountTypeFilterImportAccount,
                AccountTypeFilterReconciliationAccount,
                AccountTypeFilterLoan,
                AccountTypeFilterDebt,
                AccountTypeFilterMortgage,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AccountTypeFilter) MarshalText() ([]byte, error) {
        switch s {
        case AccountTypeFilterAll:
                return []byte(s), nil
        case AccountTypeFilterAsset:
                return []byte(s), nil
        case AccountTypeFilterCash:
                return []byte(s), nil
        case AccountTypeFilterExpense:
                return []byte(s), nil
        case AccountTypeFilterRevenue:
                return []byte(s), nil
        case AccountTypeFilterSpecial:
                return []byte(s), nil
        case AccountTypeFilterHidden:
                return []byte(s), nil
        case AccountTypeFilterLiability:
                return []byte(s), nil
        case AccountTypeFilterLiabilities:
                return []byte(s), nil
        case AccountTypeFilterDefaultAccount:
                return []byte(s), nil
        case AccountTypeFilterCashAccount:
                return []byte(s), nil
        case AccountTypeFilterAssetAccount:
                return []byte(s), nil
        case AccountTypeFilterExpenseAccount:
                return []byte(s), nil
        case AccountTypeFilterRevenueAccount:
                return []byte(s), nil
        case AccountTypeFilterInitialBalanceAccount:
                return []byte(s), nil
        case AccountTypeFilterBeneficiaryAccount:
                return []byte(s), nil
        case AccountTypeFilterImportAccount:
                return []byte(s), nil
        case AccountTypeFilterReconciliationAccount:
                return []byte(s), nil
        case AccountTypeFilterLoan:
                return []byte(s), nil
        case AccountTypeFilterDebt:
                return []byte(s), nil
        case AccountTypeFilterMortgage:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AccountTypeFilter) UnmarshalText(data []byte) error {
        switch AccountTypeFilter(data) {
        case AccountTypeFilterAll:
                *s = AccountTypeFilterAll
                return nil
        case AccountTypeFilterAsset:
                *s = AccountTypeFilterAsset
                return nil
        case AccountTypeFilterCash:
                *s = AccountTypeFilterCash
                return nil
        case AccountTypeFilterExpense:
                *s = AccountTypeFilterExpense
                return nil
        case AccountTypeFilterRevenue:
                *s = AccountTypeFilterRevenue
                return nil
        case AccountTypeFilterSpecial:
                *s = AccountTypeFilterSpecial
                return nil
        case AccountTypeFilterHidden:
                *s = AccountTypeFilterHidden
                return nil
        case AccountTypeFilterLiability:
                *s = AccountTypeFilterLiability
                return nil
        case AccountTypeFilterLiabilities:
                *s = AccountTypeFilterLiabilities
                return nil
        case AccountTypeFilterDefaultAccount:
                *s = AccountTypeFilterDefaultAccount
                return nil
        case AccountTypeFilterCashAccount:
                *s = AccountTypeFilterCashAccount
                return nil
        case AccountTypeFilterAssetAccount:
                *s = AccountTypeFilterAssetAccount
                return nil
        case AccountTypeFilterExpenseAccount:
                *s = AccountTypeFilterExpenseAccount
                return nil
        case AccountTypeFilterRevenueAccount:
                *s = AccountTypeFilterRevenueAccount
                return nil
        case AccountTypeFilterInitialBalanceAccount:
                *s = AccountTypeFilterInitialBalanceAccount
                return nil
        case AccountTypeFilterBeneficiaryAccount:
                *s = AccountTypeFilterBeneficiaryAccount
                return nil
        case AccountTypeFilterImportAccount:
                *s = AccountTypeFilterImportAccount
                return nil
        case AccountTypeFilterReconciliationAccount:
                *s = AccountTypeFilterReconciliationAccount
                return nil
        case AccountTypeFilterLoan:
                *s = AccountTypeFilterLoan
                return nil
        case AccountTypeFilterDebt:
                *s = AccountTypeFilterDebt
                return nil
        case AccountTypeFilterMortgage:
                *s = AccountTypeFilterMortgage
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/AccountTypeProperty
type AccountTypeProperty string

const (
        AccountTypePropertyDefaultAccount        AccountTypeProperty = "Default account"
        AccountTypePropertyCashAccount           AccountTypeProperty = "Cash account"
        AccountTypePropertyAssetAccount          AccountTypeProperty = "Asset account"
        AccountTypePropertyExpenseAccount        AccountTypeProperty = "Expense account"
        AccountTypePropertyRevenueAccount        AccountTypeProperty = "Revenue account"
        AccountTypePropertyInitialBalanceAccount AccountTypeProperty = "Initial balance account"
        AccountTypePropertyBeneficiaryAccount    AccountTypeProperty = "Beneficiary account"
        AccountTypePropertyImportAccount         AccountTypeProperty = "Import account"
        AccountTypePropertyReconciliationAccount AccountTypeProperty = "Reconciliation account"
        AccountTypePropertyLoan                  AccountTypeProperty = "Loan"
        AccountTypePropertyDebt                  AccountTypeProperty = "Debt"
        AccountTypePropertyMortgage              AccountTypeProperty = "Mortgage"
)

// AllValues returns all AccountTypeProperty values.
func (AccountTypeProperty) AllValues() []AccountTypeProperty {
        return []AccountTypeProperty{
                AccountTypePropertyDefaultAccount,
                AccountTypePropertyCashAccount,
                AccountTypePropertyAssetAccount,
                AccountTypePropertyExpenseAccount,
                AccountTypePropertyRevenueAccount,
                AccountTypePropertyInitialBalanceAccount,
                AccountTypePropertyBeneficiaryAccount,
                AccountTypePropertyImportAccount,
                AccountTypePropertyReconciliationAccount,
                AccountTypePropertyLoan,
                AccountTypePropertyDebt,
                AccountTypePropertyMortgage,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AccountTypeProperty) MarshalText() ([]byte, error) {
        switch s {
        case AccountTypePropertyDefaultAccount:
                return []byte(s), nil
        case AccountTypePropertyCashAccount:
                return []byte(s), nil
        case AccountTypePropertyAssetAccount:
                return []byte(s), nil
        case AccountTypePropertyExpenseAccount:
                return []byte(s), nil
        case AccountTypePropertyRevenueAccount:
                return []byte(s), nil
        case AccountTypePropertyInitialBalanceAccount:
                return []byte(s), nil
        case AccountTypePropertyBeneficiaryAccount:
                return []byte(s), nil
        case AccountTypePropertyImportAccount:
                return []byte(s), nil
        case AccountTypePropertyReconciliationAccount:
                return []byte(s), nil
        case AccountTypePropertyLoan:
                return []byte(s), nil
        case AccountTypePropertyDebt:
                return []byte(s), nil
        case AccountTypePropertyMortgage:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AccountTypeProperty) UnmarshalText(data []byte) error {
        switch AccountTypeProperty(data) {
        case AccountTypePropertyDefaultAccount:
                *s = AccountTypePropertyDefaultAccount
                return nil
        case AccountTypePropertyCashAccount:
                *s = AccountTypePropertyCashAccount
                return nil
        case AccountTypePropertyAssetAccount:
                *s = AccountTypePropertyAssetAccount
                return nil
        case AccountTypePropertyExpenseAccount:
                *s = AccountTypePropertyExpenseAccount
                return nil
        case AccountTypePropertyRevenueAccount:
                *s = AccountTypePropertyRevenueAccount
                return nil
        case AccountTypePropertyInitialBalanceAccount:
                *s = AccountTypePropertyInitialBalanceAccount
                return nil
        case AccountTypePropertyBeneficiaryAccount:
                *s = AccountTypePropertyBeneficiaryAccount
                return nil
        case AccountTypePropertyImportAccount:
                *s = AccountTypePropertyImportAccount
                return nil
        case AccountTypePropertyReconciliationAccount:
                *s = AccountTypePropertyReconciliationAccount
                return nil
        case AccountTypePropertyLoan:
                *s = AccountTypePropertyLoan
                return nil
        case AccountTypePropertyDebt:
                *s = AccountTypePropertyDebt
                return nil
        case AccountTypePropertyMortgage:
                *s = AccountTypePropertyMortgage
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/AccountUpdate
type AccountUpdate struct {
        Name               string         `json:"name"`
        Iban               OptNilString   `json:"iban"`
        Bic                OptNilString   `json:"bic"`
        AccountNumber      OptNilString   `json:"account_number"`
        OpeningBalance     OptString      `json:"opening_balance"`
        OpeningBalanceDate OptNilDateTime `json:"opening_balance_date"`
        VirtualBalance     OptString      `json:"virtual_balance"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyCode OptString `json:"currency_code"`
        // If omitted, defaults to true.
        Active OptBool `json:"active"`
        // Order of the account.
        Order OptInt32 `json:"order"`
        // If omitted, defaults to true.
        IncludeNetWorth OptBool                   `json:"include_net_worth"`
        AccountRole     OptNilAccountRoleProperty `json:"account_role"`
        CreditCardType  OptNilCreditCardType      `json:"credit_card_type"`
        // Mandatory when the account_role is ccAsset. Moment at which CC payment installments are asked for
        // by the bank.
        MonthlyPaymentDate OptNilDateTime      `json:"monthly_payment_date"`
        LiabilityType      OptNilLiabilityType `json:"liability_type"`
        // Mandatory when type is liability. Interest percentage.
        Interest       OptNilString         `json:"interest"`
        InterestPeriod OptNilInterestPeriod `json:"interest_period"`
        Notes          OptNilString         `json:"notes"`
        // Latitude of the account's location, if applicable. Can be used to draw a map. If omitted, the
        // existing location will be kept. If submitted as NULL, the current location will be removed.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the account's location, if applicable. Can be used to draw a map. If omitted, the
        // existing location will be kept. If submitted as NULL, the current location will be removed.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels. If omitted, the existing location will
        // be kept. If submitted as NULL, the current location will be removed.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetName returns the value of Name.
func (s *AccountUpdate) GetName() string {
        return s.Name
}

// GetIban returns the value of Iban.
func (s *AccountUpdate) GetIban() OptNilString {
        return s.Iban
}

// GetBic returns the value of Bic.
func (s *AccountUpdate) GetBic() OptNilString {
        return s.Bic
}

// GetAccountNumber returns the value of AccountNumber.
func (s *AccountUpdate) GetAccountNumber() OptNilString {
        return s.AccountNumber
}

// GetOpeningBalance returns the value of OpeningBalance.
func (s *AccountUpdate) GetOpeningBalance() OptString {
        return s.OpeningBalance
}

// GetOpeningBalanceDate returns the value of OpeningBalanceDate.
func (s *AccountUpdate) GetOpeningBalanceDate() OptNilDateTime {
        return s.OpeningBalanceDate
}

// GetVirtualBalance returns the value of VirtualBalance.
func (s *AccountUpdate) GetVirtualBalance() OptString {
        return s.VirtualBalance
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AccountUpdate) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AccountUpdate) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetActive returns the value of Active.
func (s *AccountUpdate) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *AccountUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetIncludeNetWorth returns the value of IncludeNetWorth.
func (s *AccountUpdate) GetIncludeNetWorth() OptBool {
        return s.IncludeNetWorth
}

// GetAccountRole returns the value of AccountRole.
func (s *AccountUpdate) GetAccountRole() OptNilAccountRoleProperty {
        return s.AccountRole
}

// GetCreditCardType returns the value of CreditCardType.
func (s *AccountUpdate) GetCreditCardType() OptNilCreditCardType {
        return s.CreditCardType
}

// GetMonthlyPaymentDate returns the value of MonthlyPaymentDate.
func (s *AccountUpdate) GetMonthlyPaymentDate() OptNilDateTime {
        return s.MonthlyPaymentDate
}

// GetLiabilityType returns the value of LiabilityType.
func (s *AccountUpdate) GetLiabilityType() OptNilLiabilityType {
        return s.LiabilityType
}

// GetInterest returns the value of Interest.
func (s *AccountUpdate) GetInterest() OptNilString {
        return s.Interest
}

// GetInterestPeriod returns the value of InterestPeriod.
func (s *AccountUpdate) GetInterestPeriod() OptNilInterestPeriod {
        return s.InterestPeriod
}

// GetNotes returns the value of Notes.
func (s *AccountUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetLatitude returns the value of Latitude.
func (s *AccountUpdate) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *AccountUpdate) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *AccountUpdate) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetName sets the value of Name.
func (s *AccountUpdate) SetName(val string) {
        s.Name = val
}

// SetIban sets the value of Iban.
func (s *AccountUpdate) SetIban(val OptNilString) {
        s.Iban = val
}

// SetBic sets the value of Bic.
func (s *AccountUpdate) SetBic(val OptNilString) {
        s.Bic = val
}

// SetAccountNumber sets the value of AccountNumber.
func (s *AccountUpdate) SetAccountNumber(val OptNilString) {
        s.AccountNumber = val
}

// SetOpeningBalance sets the value of OpeningBalance.
func (s *AccountUpdate) SetOpeningBalance(val OptString) {
        s.OpeningBalance = val
}

// SetOpeningBalanceDate sets the value of OpeningBalanceDate.
func (s *AccountUpdate) SetOpeningBalanceDate(val OptNilDateTime) {
        s.OpeningBalanceDate = val
}

// SetVirtualBalance sets the value of VirtualBalance.
func (s *AccountUpdate) SetVirtualBalance(val OptString) {
        s.VirtualBalance = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AccountUpdate) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AccountUpdate) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetActive sets the value of Active.
func (s *AccountUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *AccountUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetIncludeNetWorth sets the value of IncludeNetWorth.
func (s *AccountUpdate) SetIncludeNetWorth(val OptBool) {
        s.IncludeNetWorth = val
}

// SetAccountRole sets the value of AccountRole.
func (s *AccountUpdate) SetAccountRole(val OptNilAccountRoleProperty) {
        s.AccountRole = val
}

// SetCreditCardType sets the value of CreditCardType.
func (s *AccountUpdate) SetCreditCardType(val OptNilCreditCardType) {
        s.CreditCardType = val
}

// SetMonthlyPaymentDate sets the value of MonthlyPaymentDate.
func (s *AccountUpdate) SetMonthlyPaymentDate(val OptNilDateTime) {
        s.MonthlyPaymentDate = val
}

// SetLiabilityType sets the value of LiabilityType.
func (s *AccountUpdate) SetLiabilityType(val OptNilLiabilityType) {
        s.LiabilityType = val
}

// SetInterest sets the value of Interest.
func (s *AccountUpdate) SetInterest(val OptNilString) {
        s.Interest = val
}

// SetInterestPeriod sets the value of InterestPeriod.
func (s *AccountUpdate) SetInterestPeriod(val OptNilInterestPeriod) {
        s.InterestPeriod = val
}

// SetNotes sets the value of Notes.
func (s *AccountUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetLatitude sets the value of Latitude.
func (s *AccountUpdate) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *AccountUpdate) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *AccountUpdate) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// The object class to which the attachment must be linked.
// Ref: #/components/schemas/AttachableType
type AttachableType string

const (
        AttachableTypeAccount            AttachableType = "Account"
        AttachableTypeBudget             AttachableType = "Budget"
        AttachableTypeBill               AttachableType = "Bill"
        AttachableTypeTransactionJournal AttachableType = "TransactionJournal"
        AttachableTypePiggyBank          AttachableType = "PiggyBank"
        AttachableTypeTag                AttachableType = "Tag"
)

// AllValues returns all AttachableType values.
func (AttachableType) AllValues() []AttachableType {
        return []AttachableType{
                AttachableTypeAccount,
                AttachableTypeBudget,
                AttachableTypeBill,
                AttachableTypeTransactionJournal,
                AttachableTypePiggyBank,
                AttachableTypeTag,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AttachableType) MarshalText() ([]byte, error) {
        switch s {
        case AttachableTypeAccount:
                return []byte(s), nil
        case AttachableTypeBudget:
                return []byte(s), nil
        case AttachableTypeBill:
                return []byte(s), nil
        case AttachableTypeTransactionJournal:
                return []byte(s), nil
        case AttachableTypePiggyBank:
                return []byte(s), nil
        case AttachableTypeTag:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AttachableType) UnmarshalText(data []byte) error {
        switch AttachableType(data) {
        case AttachableTypeAccount:
                *s = AttachableTypeAccount
                return nil
        case AttachableTypeBudget:
                *s = AttachableTypeBudget
                return nil
        case AttachableTypeBill:
                *s = AttachableTypeBill
                return nil
        case AttachableTypeTransactionJournal:
                *s = AttachableTypeTransactionJournal
                return nil
        case AttachableTypePiggyBank:
                *s = AttachableTypePiggyBank
                return nil
        case AttachableTypeTag:
                *s = AttachableTypeTag
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/Attachment
type Attachment struct {
        CreatedAt      OptDateTime    `json:"created_at"`
        UpdatedAt      OptDateTime    `json:"updated_at"`
        AttachableType AttachableType `json:"attachable_type"`
        // ID of the model this attachment is linked to.
        AttachableID string `json:"attachable_id"`
        // MD5 hash of the file for basic duplicate detection.
        MD5         OptString    `json:"md5"`
        Filename    string       `json:"filename"`
        DownloadURL OptString    `json:"download_url"`
        UploadURL   OptString    `json:"upload_url"`
        Title       OptString    `json:"title"`
        Notes       OptNilString `json:"notes"`
        Mime        OptString    `json:"mime"`
        Size        OptInt32     `json:"size"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Attachment) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Attachment) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetAttachableType returns the value of AttachableType.
func (s *Attachment) GetAttachableType() AttachableType {
        return s.AttachableType
}

// GetAttachableID returns the value of AttachableID.
func (s *Attachment) GetAttachableID() string {
        return s.AttachableID
}

// GetMD5 returns the value of MD5.
func (s *Attachment) GetMD5() OptString {
        return s.MD5
}

// GetFilename returns the value of Filename.
func (s *Attachment) GetFilename() string {
        return s.Filename
}

// GetDownloadURL returns the value of DownloadURL.
func (s *Attachment) GetDownloadURL() OptString {
        return s.DownloadURL
}

// GetUploadURL returns the value of UploadURL.
func (s *Attachment) GetUploadURL() OptString {
        return s.UploadURL
}

// GetTitle returns the value of Title.
func (s *Attachment) GetTitle() OptString {
        return s.Title
}

// GetNotes returns the value of Notes.
func (s *Attachment) GetNotes() OptNilString {
        return s.Notes
}

// GetMime returns the value of Mime.
func (s *Attachment) GetMime() OptString {
        return s.Mime
}

// GetSize returns the value of Size.
func (s *Attachment) GetSize() OptInt32 {
        return s.Size
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Attachment) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Attachment) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetAttachableType sets the value of AttachableType.
func (s *Attachment) SetAttachableType(val AttachableType) {
        s.AttachableType = val
}

// SetAttachableID sets the value of AttachableID.
func (s *Attachment) SetAttachableID(val string) {
        s.AttachableID = val
}

// SetMD5 sets the value of MD5.
func (s *Attachment) SetMD5(val OptString) {
        s.MD5 = val
}

// SetFilename sets the value of Filename.
func (s *Attachment) SetFilename(val string) {
        s.Filename = val
}

// SetDownloadURL sets the value of DownloadURL.
func (s *Attachment) SetDownloadURL(val OptString) {
        s.DownloadURL = val
}

// SetUploadURL sets the value of UploadURL.
func (s *Attachment) SetUploadURL(val OptString) {
        s.UploadURL = val
}

// SetTitle sets the value of Title.
func (s *Attachment) SetTitle(val OptString) {
        s.Title = val
}

// SetNotes sets the value of Notes.
func (s *Attachment) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetMime sets the value of Mime.
func (s *Attachment) SetMime(val OptString) {
        s.Mime = val
}

// SetSize sets the value of Size.
func (s *Attachment) SetSize(val OptInt32) {
        s.Size = val
}

// Ref: #/components/schemas/AttachmentArray
type AttachmentArray struct {
        Data []AttachmentRead `json:"data"`
        Meta Meta             `json:"meta"`
}

// GetData returns the value of Data.
func (s *AttachmentArray) GetData() []AttachmentRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *AttachmentArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *AttachmentArray) SetData(val []AttachmentRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *AttachmentArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*AttachmentArray) listAttachmentByAccountRes()     {}
func (*AttachmentArray) listAttachmentByBillRes()        {}
func (*AttachmentArray) listAttachmentByBudgetRes()      {}
func (*AttachmentArray) listAttachmentByCategoryRes()    {}
func (*AttachmentArray) listAttachmentByPiggyBankRes()   {}
func (*AttachmentArray) listAttachmentByTagRes()         {}
func (*AttachmentArray) listAttachmentByTransactionRes() {}
func (*AttachmentArray) listAttachmentRes()              {}

// Ref: #/components/schemas/AttachmentRead
type AttachmentRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes Attachment `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *AttachmentRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *AttachmentRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *AttachmentRead) GetAttributes() Attachment {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *AttachmentRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *AttachmentRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *AttachmentRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *AttachmentRead) SetAttributes(val Attachment) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *AttachmentRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/AttachmentSingle
type AttachmentSingle struct {
        Data AttachmentRead `json:"data"`
}

// GetData returns the value of Data.
func (s *AttachmentSingle) GetData() AttachmentRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *AttachmentSingle) SetData(val AttachmentRead) {
        s.Data = val
}

func (*AttachmentSingle) getAttachmentRes()    {}
func (*AttachmentSingle) storeAttachmentRes()  {}
func (*AttachmentSingle) updateAttachmentRes() {}

// Ref: #/components/schemas/AttachmentStore
type AttachmentStore struct {
        Filename       string         `json:"filename"`
        AttachableType AttachableType `json:"attachable_type"`
        // ID of the model this attachment is linked to.
        AttachableID string       `json:"attachable_id"`
        Title        OptString    `json:"title"`
        Notes        OptNilString `json:"notes"`
}

// GetFilename returns the value of Filename.
func (s *AttachmentStore) GetFilename() string {
        return s.Filename
}

// GetAttachableType returns the value of AttachableType.
func (s *AttachmentStore) GetAttachableType() AttachableType {
        return s.AttachableType
}

// GetAttachableID returns the value of AttachableID.
func (s *AttachmentStore) GetAttachableID() string {
        return s.AttachableID
}

// GetTitle returns the value of Title.
func (s *AttachmentStore) GetTitle() OptString {
        return s.Title
}

// GetNotes returns the value of Notes.
func (s *AttachmentStore) GetNotes() OptNilString {
        return s.Notes
}

// SetFilename sets the value of Filename.
func (s *AttachmentStore) SetFilename(val string) {
        s.Filename = val
}

// SetAttachableType sets the value of AttachableType.
func (s *AttachmentStore) SetAttachableType(val AttachableType) {
        s.AttachableType = val
}

// SetAttachableID sets the value of AttachableID.
func (s *AttachmentStore) SetAttachableID(val string) {
        s.AttachableID = val
}

// SetTitle sets the value of Title.
func (s *AttachmentStore) SetTitle(val OptString) {
        s.Title = val
}

// SetNotes sets the value of Notes.
func (s *AttachmentStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// Ref: #/components/schemas/AttachmentUpdate
type AttachmentUpdate struct {
        Filename OptString    `json:"filename"`
        Title    OptString    `json:"title"`
        Notes    OptNilString `json:"notes"`
}

// GetFilename returns the value of Filename.
func (s *AttachmentUpdate) GetFilename() OptString {
        return s.Filename
}

// GetTitle returns the value of Title.
func (s *AttachmentUpdate) GetTitle() OptString {
        return s.Title
}

// GetNotes returns the value of Notes.
func (s *AttachmentUpdate) GetNotes() OptNilString {
        return s.Notes
}

// SetFilename sets the value of Filename.
func (s *AttachmentUpdate) SetFilename(val OptString) {
        s.Filename = val
}

// SetTitle sets the value of Title.
func (s *AttachmentUpdate) SetTitle(val OptString) {
        s.Title = val
}

// SetNotes sets the value of Notes.
func (s *AttachmentUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// Period for the auto budget.
// Ref: #/components/schemas/AutoBudgetPeriod
type AutoBudgetPeriod string

const (
        AutoBudgetPeriodDaily     AutoBudgetPeriod = "daily"
        AutoBudgetPeriodWeekly    AutoBudgetPeriod = "weekly"
        AutoBudgetPeriodMonthly   AutoBudgetPeriod = "monthly"
        AutoBudgetPeriodQuarterly AutoBudgetPeriod = "quarterly"
        AutoBudgetPeriodHalfYear  AutoBudgetPeriod = "half-year"
        AutoBudgetPeriodYearly    AutoBudgetPeriod = "yearly"
)

// AllValues returns all AutoBudgetPeriod values.
func (AutoBudgetPeriod) AllValues() []AutoBudgetPeriod {
        return []AutoBudgetPeriod{
                AutoBudgetPeriodDaily,
                AutoBudgetPeriodWeekly,
                AutoBudgetPeriodMonthly,
                AutoBudgetPeriodQuarterly,
                AutoBudgetPeriodHalfYear,
                AutoBudgetPeriodYearly,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AutoBudgetPeriod) MarshalText() ([]byte, error) {
        switch s {
        case AutoBudgetPeriodDaily:
                return []byte(s), nil
        case AutoBudgetPeriodWeekly:
                return []byte(s), nil
        case AutoBudgetPeriodMonthly:
                return []byte(s), nil
        case AutoBudgetPeriodQuarterly:
                return []byte(s), nil
        case AutoBudgetPeriodHalfYear:
                return []byte(s), nil
        case AutoBudgetPeriodYearly:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AutoBudgetPeriod) UnmarshalText(data []byte) error {
        switch AutoBudgetPeriod(data) {
        case AutoBudgetPeriodDaily:
                *s = AutoBudgetPeriodDaily
                return nil
        case AutoBudgetPeriodWeekly:
                *s = AutoBudgetPeriodWeekly
                return nil
        case AutoBudgetPeriodMonthly:
                *s = AutoBudgetPeriodMonthly
                return nil
        case AutoBudgetPeriodQuarterly:
                *s = AutoBudgetPeriodQuarterly
                return nil
        case AutoBudgetPeriodHalfYear:
                *s = AutoBudgetPeriodHalfYear
                return nil
        case AutoBudgetPeriodYearly:
                *s = AutoBudgetPeriodYearly
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// The type of auto-budget that Firefly III must create.
// Ref: #/components/schemas/AutoBudgetType
type AutoBudgetType string

const (
        AutoBudgetTypeReset    AutoBudgetType = "reset"
        AutoBudgetTypeRollover AutoBudgetType = "rollover"
        AutoBudgetTypeNone     AutoBudgetType = "none"
)

// AllValues returns all AutoBudgetType values.
func (AutoBudgetType) AllValues() []AutoBudgetType {
        return []AutoBudgetType{
                AutoBudgetTypeReset,
                AutoBudgetTypeRollover,
                AutoBudgetTypeNone,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s AutoBudgetType) MarshalText() ([]byte, error) {
        switch s {
        case AutoBudgetTypeReset:
                return []byte(s), nil
        case AutoBudgetTypeRollover:
                return []byte(s), nil
        case AutoBudgetTypeNone:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *AutoBudgetType) UnmarshalText(data []byte) error {
        switch AutoBudgetType(data) {
        case AutoBudgetTypeReset:
                *s = AutoBudgetTypeReset
                return nil
        case AutoBudgetTypeRollover:
                *s = AutoBudgetTypeRollover
                return nil
        case AutoBudgetTypeNone:
                *s = AutoBudgetTypeNone
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/AutocompleteAccount
type AutocompleteAccount struct {
        ID string `json:"id"`
        // Name of the account found by an auto-complete search.
        Name string `json:"name"`
        // Asset accounts and liabilities have a second field with the given date's account balance.
        NameWithBalance string `json:"name_with_balance"`
        // Account type of the account found by the auto-complete search.
        Type string `json:"type"`
        // ID for the currency used by this account.
        CurrencyID string `json:"currency_id"`
        // Currency name for the currency used by this account.
        CurrencyName string `json:"currency_name"`
        // Currency code for the currency used by this account.
        CurrencyCode string `json:"currency_code"`
        // Currency symbol for the currency used by this account.
        CurrencySymbol string `json:"currency_symbol"`
        // Number of decimal places for the currency used by this account.
        CurrencyDecimalPlaces int32 `json:"currency_decimal_places"`
}

// GetID returns the value of ID.
func (s *AutocompleteAccount) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteAccount) GetName() string {
        return s.Name
}

// GetNameWithBalance returns the value of NameWithBalance.
func (s *AutocompleteAccount) GetNameWithBalance() string {
        return s.NameWithBalance
}

// GetType returns the value of Type.
func (s *AutocompleteAccount) GetType() string {
        return s.Type
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AutocompleteAccount) GetCurrencyID() string {
        return s.CurrencyID
}

// GetCurrencyName returns the value of CurrencyName.
func (s *AutocompleteAccount) GetCurrencyName() string {
        return s.CurrencyName
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AutocompleteAccount) GetCurrencyCode() string {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *AutocompleteAccount) GetCurrencySymbol() string {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *AutocompleteAccount) GetCurrencyDecimalPlaces() int32 {
        return s.CurrencyDecimalPlaces
}

// SetID sets the value of ID.
func (s *AutocompleteAccount) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteAccount) SetName(val string) {
        s.Name = val
}

// SetNameWithBalance sets the value of NameWithBalance.
func (s *AutocompleteAccount) SetNameWithBalance(val string) {
        s.NameWithBalance = val
}

// SetType sets the value of Type.
func (s *AutocompleteAccount) SetType(val string) {
        s.Type = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AutocompleteAccount) SetCurrencyID(val string) {
        s.CurrencyID = val
}

// SetCurrencyName sets the value of CurrencyName.
func (s *AutocompleteAccount) SetCurrencyName(val string) {
        s.CurrencyName = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AutocompleteAccount) SetCurrencyCode(val string) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *AutocompleteAccount) SetCurrencySymbol(val string) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *AutocompleteAccount) SetCurrencyDecimalPlaces(val int32) {
        s.CurrencyDecimalPlaces = val
}

type AutocompleteAccountArray []AutocompleteAccount

func (*AutocompleteAccountArray) getAccountsACRes() {}

// Ref: #/components/schemas/AutocompleteBill
type AutocompleteBill struct {
        ID string `json:"id"`
        // Name of the bill found by an auto-complete search.
        Name string `json:"name"`
        // Is the bill active or not?.
        Active OptBool `json:"active"`
}

// GetID returns the value of ID.
func (s *AutocompleteBill) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteBill) GetName() string {
        return s.Name
}

// GetActive returns the value of Active.
func (s *AutocompleteBill) GetActive() OptBool {
        return s.Active
}

// SetID sets the value of ID.
func (s *AutocompleteBill) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteBill) SetName(val string) {
        s.Name = val
}

// SetActive sets the value of Active.
func (s *AutocompleteBill) SetActive(val OptBool) {
        s.Active = val
}

type AutocompleteBillArray []AutocompleteBill

func (*AutocompleteBillArray) getBillsACRes() {}

// Ref: #/components/schemas/AutocompleteBudget
type AutocompleteBudget struct {
        ID string `json:"id"`
        // Name of the budget found by an auto-complete search.
        Name string `json:"name"`
}

// GetID returns the value of ID.
func (s *AutocompleteBudget) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteBudget) GetName() string {
        return s.Name
}

// SetID sets the value of ID.
func (s *AutocompleteBudget) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteBudget) SetName(val string) {
        s.Name = val
}

type AutocompleteBudgetArray []AutocompleteBudget

func (*AutocompleteBudgetArray) getBudgetsACRes() {}

// Ref: #/components/schemas/AutocompleteCategory
type AutocompleteCategory struct {
        ID string `json:"id"`
        // Name of the category found by an auto-complete search.
        Name string `json:"name"`
}

// GetID returns the value of ID.
func (s *AutocompleteCategory) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteCategory) GetName() string {
        return s.Name
}

// SetID sets the value of ID.
func (s *AutocompleteCategory) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteCategory) SetName(val string) {
        s.Name = val
}

type AutocompleteCategoryArray []AutocompleteCategory

func (*AutocompleteCategoryArray) getCategoriesACRes() {}

// Ref: #/components/schemas/AutocompleteCurrency
type AutocompleteCurrency struct {
        ID string `json:"id"`
        // Currency name.
        Name string `json:"name"`
        // Currency code.
        Code          string `json:"code"`
        Symbol        string `json:"symbol"`
        DecimalPlaces int32  `json:"decimal_places"`
}

// GetID returns the value of ID.
func (s *AutocompleteCurrency) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteCurrency) GetName() string {
        return s.Name
}

// GetCode returns the value of Code.
func (s *AutocompleteCurrency) GetCode() string {
        return s.Code
}

// GetSymbol returns the value of Symbol.
func (s *AutocompleteCurrency) GetSymbol() string {
        return s.Symbol
}

// GetDecimalPlaces returns the value of DecimalPlaces.
func (s *AutocompleteCurrency) GetDecimalPlaces() int32 {
        return s.DecimalPlaces
}

// SetID sets the value of ID.
func (s *AutocompleteCurrency) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteCurrency) SetName(val string) {
        s.Name = val
}

// SetCode sets the value of Code.
func (s *AutocompleteCurrency) SetCode(val string) {
        s.Code = val
}

// SetSymbol sets the value of Symbol.
func (s *AutocompleteCurrency) SetSymbol(val string) {
        s.Symbol = val
}

// SetDecimalPlaces sets the value of DecimalPlaces.
func (s *AutocompleteCurrency) SetDecimalPlaces(val int32) {
        s.DecimalPlaces = val
}

type AutocompleteCurrencyArray []AutocompleteCurrency

func (*AutocompleteCurrencyArray) getCurrenciesACRes() {}

// Ref: #/components/schemas/AutocompleteCurrencyCode
type AutocompleteCurrencyCode struct {
        ID string `json:"id"`
        // Currency name with the code between brackets.
        Name string `json:"name"`
        // Currency code.
        Code          string `json:"code"`
        Symbol        string `json:"symbol"`
        DecimalPlaces int32  `json:"decimal_places"`
}

// GetID returns the value of ID.
func (s *AutocompleteCurrencyCode) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteCurrencyCode) GetName() string {
        return s.Name
}

// GetCode returns the value of Code.
func (s *AutocompleteCurrencyCode) GetCode() string {
        return s.Code
}

// GetSymbol returns the value of Symbol.
func (s *AutocompleteCurrencyCode) GetSymbol() string {
        return s.Symbol
}

// GetDecimalPlaces returns the value of DecimalPlaces.
func (s *AutocompleteCurrencyCode) GetDecimalPlaces() int32 {
        return s.DecimalPlaces
}

// SetID sets the value of ID.
func (s *AutocompleteCurrencyCode) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteCurrencyCode) SetName(val string) {
        s.Name = val
}

// SetCode sets the value of Code.
func (s *AutocompleteCurrencyCode) SetCode(val string) {
        s.Code = val
}

// SetSymbol sets the value of Symbol.
func (s *AutocompleteCurrencyCode) SetSymbol(val string) {
        s.Symbol = val
}

// SetDecimalPlaces sets the value of DecimalPlaces.
func (s *AutocompleteCurrencyCode) SetDecimalPlaces(val int32) {
        s.DecimalPlaces = val
}

type AutocompleteCurrencyCodeArray []AutocompleteCurrencyCode

func (*AutocompleteCurrencyCodeArray) getCurrenciesCodeACRes() {}

// Ref: #/components/schemas/AutocompleteObjectGroup
type AutocompleteObjectGroup struct {
        ID string `json:"id"`
        // Title of the object group found by an auto-complete search.
        Title string `json:"title"`
        // Title of the object group found by an auto-complete search.
        Name string `json:"name"`
}

// GetID returns the value of ID.
func (s *AutocompleteObjectGroup) GetID() string {
        return s.ID
}

// GetTitle returns the value of Title.
func (s *AutocompleteObjectGroup) GetTitle() string {
        return s.Title
}

// GetName returns the value of Name.
func (s *AutocompleteObjectGroup) GetName() string {
        return s.Name
}

// SetID sets the value of ID.
func (s *AutocompleteObjectGroup) SetID(val string) {
        s.ID = val
}

// SetTitle sets the value of Title.
func (s *AutocompleteObjectGroup) SetTitle(val string) {
        s.Title = val
}

// SetName sets the value of Name.
func (s *AutocompleteObjectGroup) SetName(val string) {
        s.Name = val
}

type AutocompleteObjectGroupArray []AutocompleteObjectGroup

func (*AutocompleteObjectGroupArray) getObjectGroupsACRes() {}

// Ref: #/components/schemas/AutocompletePiggy
type AutocompletePiggy struct {
        ID string `json:"id"`
        // Name of the piggy bank found by an auto-complete search.
        Name string `json:"name"`
        // Currency ID for this piggy bank.
        CurrencyID OptString `json:"currency_id"`
        // Currency code for this piggy bank.
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Currency name for the currency used by this account.
        CurrencyName          OptString `json:"currency_name"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetID returns the value of ID.
func (s *AutocompletePiggy) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompletePiggy) GetName() string {
        return s.Name
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AutocompletePiggy) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AutocompletePiggy) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *AutocompletePiggy) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyName returns the value of CurrencyName.
func (s *AutocompletePiggy) GetCurrencyName() OptString {
        return s.CurrencyName
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *AutocompletePiggy) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *AutocompletePiggy) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *AutocompletePiggy) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetID sets the value of ID.
func (s *AutocompletePiggy) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompletePiggy) SetName(val string) {
        s.Name = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AutocompletePiggy) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AutocompletePiggy) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *AutocompletePiggy) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyName sets the value of CurrencyName.
func (s *AutocompletePiggy) SetCurrencyName(val OptString) {
        s.CurrencyName = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *AutocompletePiggy) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *AutocompletePiggy) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *AutocompletePiggy) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

type AutocompletePiggyArray []AutocompletePiggy

func (*AutocompletePiggyArray) getPiggiesACRes() {}

// Ref: #/components/schemas/AutocompletePiggyBalance
type AutocompletePiggyBalance struct {
        ID string `json:"id"`
        // Name of the piggy bank found by an auto-complete search.
        Name string `json:"name"`
        // Name of the piggy bank found by an auto-complete search with the current balance formatted nicely.
        NameWithBalance OptString `json:"name_with_balance"`
        // Currency ID for this piggy bank.
        CurrencyID OptString `json:"currency_id"`
        // Currency code for this piggy bank.
        CurrencyCode          OptString `json:"currency_code"`
        CurrencySymbol        OptString `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetID returns the value of ID.
func (s *AutocompletePiggyBalance) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompletePiggyBalance) GetName() string {
        return s.Name
}

// GetNameWithBalance returns the value of NameWithBalance.
func (s *AutocompletePiggyBalance) GetNameWithBalance() OptString {
        return s.NameWithBalance
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AutocompletePiggyBalance) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AutocompletePiggyBalance) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *AutocompletePiggyBalance) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *AutocompletePiggyBalance) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *AutocompletePiggyBalance) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *AutocompletePiggyBalance) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetID sets the value of ID.
func (s *AutocompletePiggyBalance) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompletePiggyBalance) SetName(val string) {
        s.Name = val
}

// SetNameWithBalance sets the value of NameWithBalance.
func (s *AutocompletePiggyBalance) SetNameWithBalance(val OptString) {
        s.NameWithBalance = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AutocompletePiggyBalance) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AutocompletePiggyBalance) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *AutocompletePiggyBalance) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *AutocompletePiggyBalance) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *AutocompletePiggyBalance) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *AutocompletePiggyBalance) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

type AutocompletePiggyBalanceArray []AutocompletePiggyBalance

func (*AutocompletePiggyBalanceArray) getPiggiesBalanceACRes() {}

// Ref: #/components/schemas/AutocompleteRecurrence
type AutocompleteRecurrence struct {
        ID string `json:"id"`
        // Name of the recurrence found by an auto-complete search.
        Name string `json:"name"`
        // Description of the recurrence found by auto-complete.
        Description OptString `json:"description"`
}

// GetID returns the value of ID.
func (s *AutocompleteRecurrence) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteRecurrence) GetName() string {
        return s.Name
}

// GetDescription returns the value of Description.
func (s *AutocompleteRecurrence) GetDescription() OptString {
        return s.Description
}

// SetID sets the value of ID.
func (s *AutocompleteRecurrence) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteRecurrence) SetName(val string) {
        s.Name = val
}

// SetDescription sets the value of Description.
func (s *AutocompleteRecurrence) SetDescription(val OptString) {
        s.Description = val
}

type AutocompleteRecurrenceArray []AutocompleteRecurrence

func (*AutocompleteRecurrenceArray) getRecurringACRes() {}

// Ref: #/components/schemas/AutocompleteRule
type AutocompleteRule struct {
        ID string `json:"id"`
        // Name of the rule found by an auto-complete search.
        Name string `json:"name"`
        // Description of the rule found by auto-complete.
        Description OptString `json:"description"`
}

// GetID returns the value of ID.
func (s *AutocompleteRule) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteRule) GetName() string {
        return s.Name
}

// GetDescription returns the value of Description.
func (s *AutocompleteRule) GetDescription() OptString {
        return s.Description
}

// SetID sets the value of ID.
func (s *AutocompleteRule) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteRule) SetName(val string) {
        s.Name = val
}

// SetDescription sets the value of Description.
func (s *AutocompleteRule) SetDescription(val OptString) {
        s.Description = val
}

type AutocompleteRuleArray []AutocompleteRule

func (*AutocompleteRuleArray) getRulesACRes() {}

// Ref: #/components/schemas/AutocompleteRuleGroup
type AutocompleteRuleGroup struct {
        ID string `json:"id"`
        // Name of the rule group found by an auto-complete search.
        Name string `json:"name"`
        // Description of the rule group found by auto-complete.
        Description OptString `json:"description"`
}

// GetID returns the value of ID.
func (s *AutocompleteRuleGroup) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteRuleGroup) GetName() string {
        return s.Name
}

// GetDescription returns the value of Description.
func (s *AutocompleteRuleGroup) GetDescription() OptString {
        return s.Description
}

// SetID sets the value of ID.
func (s *AutocompleteRuleGroup) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteRuleGroup) SetName(val string) {
        s.Name = val
}

// SetDescription sets the value of Description.
func (s *AutocompleteRuleGroup) SetDescription(val OptString) {
        s.Description = val
}

type AutocompleteRuleGroupArray []AutocompleteRuleGroup

func (*AutocompleteRuleGroupArray) getRuleGroupsACRes() {}

// Ref: #/components/schemas/AutocompleteTag
type AutocompleteTag struct {
        ID string `json:"id"`
        // Name of the tag found by an auto-complete search.
        Name string `json:"name"`
        // Name of the tag found by an auto-complete search.
        Tag string `json:"tag"`
}

// GetID returns the value of ID.
func (s *AutocompleteTag) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteTag) GetName() string {
        return s.Name
}

// GetTag returns the value of Tag.
func (s *AutocompleteTag) GetTag() string {
        return s.Tag
}

// SetID sets the value of ID.
func (s *AutocompleteTag) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteTag) SetName(val string) {
        s.Name = val
}

// SetTag sets the value of Tag.
func (s *AutocompleteTag) SetTag(val string) {
        s.Tag = val
}

type AutocompleteTagArray []AutocompleteTag

func (*AutocompleteTagArray) getTagACRes() {}

// Ref: #/components/schemas/AutocompleteTransaction
type AutocompleteTransaction struct {
        // The ID of a transaction journal (basically a single split).
        ID string `json:"id"`
        // The ID of the underlying transaction group.
        TransactionGroupID OptString `json:"transaction_group_id"`
        // Transaction description.
        Name string `json:"name"`
        // Transaction description.
        Description string `json:"description"`
}

// GetID returns the value of ID.
func (s *AutocompleteTransaction) GetID() string {
        return s.ID
}

// GetTransactionGroupID returns the value of TransactionGroupID.
func (s *AutocompleteTransaction) GetTransactionGroupID() OptString {
        return s.TransactionGroupID
}

// GetName returns the value of Name.
func (s *AutocompleteTransaction) GetName() string {
        return s.Name
}

// GetDescription returns the value of Description.
func (s *AutocompleteTransaction) GetDescription() string {
        return s.Description
}

// SetID sets the value of ID.
func (s *AutocompleteTransaction) SetID(val string) {
        s.ID = val
}

// SetTransactionGroupID sets the value of TransactionGroupID.
func (s *AutocompleteTransaction) SetTransactionGroupID(val OptString) {
        s.TransactionGroupID = val
}

// SetName sets the value of Name.
func (s *AutocompleteTransaction) SetName(val string) {
        s.Name = val
}

// SetDescription sets the value of Description.
func (s *AutocompleteTransaction) SetDescription(val string) {
        s.Description = val
}

type AutocompleteTransactionArray []AutocompleteTransaction

func (*AutocompleteTransactionArray) getTransactionsACRes() {}

// Ref: #/components/schemas/AutocompleteTransactionID
type AutocompleteTransactionID struct {
        // The ID of a transaction journal (basically a single split).
        ID string `json:"id"`
        // The ID of the underlying transaction group.
        TransactionGroupID OptString `json:"transaction_group_id"`
        // Transaction description with ID in the name.
        Name string `json:"name"`
        // Transaction description with ID in the name.
        Description string `json:"description"`
}

// GetID returns the value of ID.
func (s *AutocompleteTransactionID) GetID() string {
        return s.ID
}

// GetTransactionGroupID returns the value of TransactionGroupID.
func (s *AutocompleteTransactionID) GetTransactionGroupID() OptString {
        return s.TransactionGroupID
}

// GetName returns the value of Name.
func (s *AutocompleteTransactionID) GetName() string {
        return s.Name
}

// GetDescription returns the value of Description.
func (s *AutocompleteTransactionID) GetDescription() string {
        return s.Description
}

// SetID sets the value of ID.
func (s *AutocompleteTransactionID) SetID(val string) {
        s.ID = val
}

// SetTransactionGroupID sets the value of TransactionGroupID.
func (s *AutocompleteTransactionID) SetTransactionGroupID(val OptString) {
        s.TransactionGroupID = val
}

// SetName sets the value of Name.
func (s *AutocompleteTransactionID) SetName(val string) {
        s.Name = val
}

// SetDescription sets the value of Description.
func (s *AutocompleteTransactionID) SetDescription(val string) {
        s.Description = val
}

type AutocompleteTransactionIDArray []AutocompleteTransactionID

func (*AutocompleteTransactionIDArray) getTransactionsIDACRes() {}

// Ref: #/components/schemas/AutocompleteTransactionType
type AutocompleteTransactionType struct {
        ID string `json:"id"`
        // Type of the object found by an auto-complete search.
        Name string `json:"name"`
        // Name of the object found by an auto-complete search.
        Type string `json:"type"`
}

// GetID returns the value of ID.
func (s *AutocompleteTransactionType) GetID() string {
        return s.ID
}

// GetName returns the value of Name.
func (s *AutocompleteTransactionType) GetName() string {
        return s.Name
}

// GetType returns the value of Type.
func (s *AutocompleteTransactionType) GetType() string {
        return s.Type
}

// SetID sets the value of ID.
func (s *AutocompleteTransactionType) SetID(val string) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *AutocompleteTransactionType) SetName(val string) {
        s.Name = val
}

// SetType sets the value of Type.
func (s *AutocompleteTransactionType) SetType(val string) {
        s.Type = val
}

type AutocompleteTransactionTypeArray []AutocompleteTransactionType

func (*AutocompleteTransactionTypeArray) getTransactionTypesACRes() {}

// Ref: #/components/schemas/AvailableBudget
type AvailableBudget struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // Use either currency_id or currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code.
        CurrencyCode          OptString `json:"currency_code"`
        CurrencySymbol        OptString `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        Amount                string    `json:"amount"`
        // Start date of the available budget.
        Start time.Time `json:"start"`
        // End date of the available budget.
        End                time.Time     `json:"end"`
        SpentInBudgets     []BudgetSpent `json:"spent_in_budgets"`
        SpentOutsideBudget []BudgetSpent `json:"spent_outside_budget"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *AvailableBudget) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *AvailableBudget) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetCurrencyID returns the value of CurrencyID.
func (s *AvailableBudget) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *AvailableBudget) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *AvailableBudget) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *AvailableBudget) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetAmount returns the value of Amount.
func (s *AvailableBudget) GetAmount() string {
        return s.Amount
}

// GetStart returns the value of Start.
func (s *AvailableBudget) GetStart() time.Time {
        return s.Start
}

// GetEnd returns the value of End.
func (s *AvailableBudget) GetEnd() time.Time {
        return s.End
}

// GetSpentInBudgets returns the value of SpentInBudgets.
func (s *AvailableBudget) GetSpentInBudgets() []BudgetSpent {
        return s.SpentInBudgets
}

// GetSpentOutsideBudget returns the value of SpentOutsideBudget.
func (s *AvailableBudget) GetSpentOutsideBudget() []BudgetSpent {
        return s.SpentOutsideBudget
}

// SetCreatedAt sets the value of CreatedAt.
func (s *AvailableBudget) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *AvailableBudget) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *AvailableBudget) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *AvailableBudget) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *AvailableBudget) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *AvailableBudget) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetAmount sets the value of Amount.
func (s *AvailableBudget) SetAmount(val string) {
        s.Amount = val
}

// SetStart sets the value of Start.
func (s *AvailableBudget) SetStart(val time.Time) {
        s.Start = val
}

// SetEnd sets the value of End.
func (s *AvailableBudget) SetEnd(val time.Time) {
        s.End = val
}

// SetSpentInBudgets sets the value of SpentInBudgets.
func (s *AvailableBudget) SetSpentInBudgets(val []BudgetSpent) {
        s.SpentInBudgets = val
}

// SetSpentOutsideBudget sets the value of SpentOutsideBudget.
func (s *AvailableBudget) SetSpentOutsideBudget(val []BudgetSpent) {
        s.SpentOutsideBudget = val
}

// Ref: #/components/schemas/AvailableBudgetArray
type AvailableBudgetArray struct {
        Data []AvailableBudgetRead `json:"data"`
        Meta Meta                  `json:"meta"`
}

// GetData returns the value of Data.
func (s *AvailableBudgetArray) GetData() []AvailableBudgetRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *AvailableBudgetArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *AvailableBudgetArray) SetData(val []AvailableBudgetRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *AvailableBudgetArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*AvailableBudgetArray) listAvailableBudgetByCurrencyRes() {}
func (*AvailableBudgetArray) listAvailableBudgetRes()           {}

// Ref: #/components/schemas/AvailableBudgetRead
type AvailableBudgetRead struct {
        // Immutable value.
        Type       string          `json:"type"`
        ID         string          `json:"id"`
        Attributes AvailableBudget `json:"attributes"`
}

// GetType returns the value of Type.
func (s *AvailableBudgetRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *AvailableBudgetRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *AvailableBudgetRead) GetAttributes() AvailableBudget {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *AvailableBudgetRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *AvailableBudgetRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *AvailableBudgetRead) SetAttributes(val AvailableBudget) {
        s.Attributes = val
}

// Ref: #/components/schemas/AvailableBudgetSingle
type AvailableBudgetSingle struct {
        Data AvailableBudgetRead `json:"data"`
}

// GetData returns the value of Data.
func (s *AvailableBudgetSingle) GetData() AvailableBudgetRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *AvailableBudgetSingle) SetData(val AvailableBudgetRead) {
        s.Data = val
}

func (*AvailableBudgetSingle) getAvailableBudgetRes() {}

// Ref: #/components/schemas/BadRequest
type BadRequest struct {
        Message   OptString `json:"message"`
        Exception OptString `json:"exception"`
}

// GetMessage returns the value of Message.
func (s *BadRequest) GetMessage() OptString {
        return s.Message
}

// GetException returns the value of Exception.
func (s *BadRequest) GetException() OptString {
        return s.Exception
}

// SetMessage sets the value of Message.
func (s *BadRequest) SetMessage(val OptString) {
        s.Message = val
}

// SetException sets the value of Exception.
func (s *BadRequest) SetException(val OptString) {
        s.Exception = val
}

func (*BadRequest) bulkUpdateTransactionsRes()         {}
func (*BadRequest) defaultCurrencyRes()                {}
func (*BadRequest) deleteAccountRes()                  {}
func (*BadRequest) deleteAttachmentRes()               {}
func (*BadRequest) deleteBillRes()                     {}
func (*BadRequest) deleteBudgetLimitRes()              {}
func (*BadRequest) deleteBudgetRes()                   {}
func (*BadRequest) deleteCategoryRes()                 {}
func (*BadRequest) deleteCurrencyRes()                 {}
func (*BadRequest) deleteLinkTypeRes()                 {}
func (*BadRequest) deleteObjectGroupRes()              {}
func (*BadRequest) deletePiggyBankRes()                {}
func (*BadRequest) deleteRecurrenceRes()               {}
func (*BadRequest) deleteRuleGroupRes()                {}
func (*BadRequest) deleteRuleRes()                     {}
func (*BadRequest) deleteTagRes()                      {}
func (*BadRequest) deleteTransactionJournalRes()       {}
func (*BadRequest) deleteTransactionLinkRes()          {}
func (*BadRequest) deleteTransactionRes()              {}
func (*BadRequest) deleteUserRes()                     {}
func (*BadRequest) deleteWebhookMessageAttemptRes()    {}
func (*BadRequest) deleteWebhookMessageRes()           {}
func (*BadRequest) deleteWebhookRes()                  {}
func (*BadRequest) destroyDataRes()                    {}
func (*BadRequest) disableCurrencyRes()                {}
func (*BadRequest) downloadAttachmentRes()             {}
func (*BadRequest) enableCurrencyRes()                 {}
func (*BadRequest) exportAccountsRes()                 {}
func (*BadRequest) exportBillsRes()                    {}
func (*BadRequest) exportBudgetsRes()                  {}
func (*BadRequest) exportCategoriesRes()               {}
func (*BadRequest) exportPiggiesRes()                  {}
func (*BadRequest) exportRecurringRes()                {}
func (*BadRequest) exportRulesRes()                    {}
func (*BadRequest) exportTagsRes()                     {}
func (*BadRequest) exportTransactionsRes()             {}
func (*BadRequest) fireRuleGroupRes()                  {}
func (*BadRequest) fireRuleRes()                       {}
func (*BadRequest) getAboutRes()                       {}
func (*BadRequest) getAccountRes()                     {}
func (*BadRequest) getAccountsACRes()                  {}
func (*BadRequest) getAttachmentRes()                  {}
func (*BadRequest) getAvailableBudgetRes()             {}
func (*BadRequest) getBasicSummaryRes()                {}
func (*BadRequest) getBillRes()                        {}
func (*BadRequest) getBillsACRes()                     {}
func (*BadRequest) getBudgetLimitRes()                 {}
func (*BadRequest) getBudgetRes()                      {}
func (*BadRequest) getBudgetsACRes()                   {}
func (*BadRequest) getCategoriesACRes()                {}
func (*BadRequest) getCategoryRes()                    {}
func (*BadRequest) getChartAccountOverviewRes()        {}
func (*BadRequest) getConfigurationRes()               {}
func (*BadRequest) getCronRes()                        {}
func (*BadRequest) getCurrenciesACRes()                {}
func (*BadRequest) getCurrenciesCodeACRes()            {}
func (*BadRequest) getCurrencyRes()                    {}
func (*BadRequest) getCurrentUserRes()                 {}
func (*BadRequest) getDefaultCurrencyRes()             {}
func (*BadRequest) getLinkTypeRes()                    {}
func (*BadRequest) getObjectGroupRes()                 {}
func (*BadRequest) getObjectGroupsACRes()              {}
func (*BadRequest) getPiggiesACRes()                   {}
func (*BadRequest) getPiggiesBalanceACRes()            {}
func (*BadRequest) getPiggyBankRes()                   {}
func (*BadRequest) getPreferenceRes()                  {}
func (*BadRequest) getRecurrenceRes()                  {}
func (*BadRequest) getRecurringACRes()                 {}
func (*BadRequest) getRuleGroupRes()                   {}
func (*BadRequest) getRuleGroupsACRes()                {}
func (*BadRequest) getRuleRes()                        {}
func (*BadRequest) getRulesACRes()                     {}
func (*BadRequest) getSingleConfigurationRes()         {}
func (*BadRequest) getSingleWebhookMessageAttemptRes() {}
func (*BadRequest) getSingleWebhookMessageRes()        {}
func (*BadRequest) getTagACRes()                       {}
func (*BadRequest) getTagRes()                         {}
func (*BadRequest) getTransactionByJournalRes()        {}
func (*BadRequest) getTransactionLinkRes()             {}
func (*BadRequest) getTransactionRes()                 {}
func (*BadRequest) getTransactionTypesACRes()          {}
func (*BadRequest) getTransactionsACRes()              {}
func (*BadRequest) getTransactionsIDACRes()            {}
func (*BadRequest) getUserRes()                        {}
func (*BadRequest) getWebhookMessageAttemptsRes()      {}
func (*BadRequest) getWebhookMessagesRes()             {}
func (*BadRequest) getWebhookRes()                     {}
func (*BadRequest) insightExpenseAssetRes()            {}
func (*BadRequest) insightExpenseBillRes()             {}
func (*BadRequest) insightExpenseBudgetRes()           {}
func (*BadRequest) insightExpenseCategoryRes()         {}
func (*BadRequest) insightExpenseExpenseRes()          {}
func (*BadRequest) insightExpenseNoBillRes()           {}
func (*BadRequest) insightExpenseNoBudgetRes()         {}
func (*BadRequest) insightExpenseNoCategoryRes()       {}
func (*BadRequest) insightExpenseNoTagRes()            {}
func (*BadRequest) insightExpenseTagRes()              {}
func (*BadRequest) insightExpenseTotalRes()            {}
func (*BadRequest) insightIncomeAssetRes()             {}
func (*BadRequest) insightIncomeCategoryRes()          {}
func (*BadRequest) insightIncomeNoCategoryRes()        {}
func (*BadRequest) insightIncomeNoTagRes()             {}
func (*BadRequest) insightIncomeRevenueRes()           {}
func (*BadRequest) insightIncomeTagRes()               {}
func (*BadRequest) insightIncomeTotalRes()             {}
func (*BadRequest) insightTransferCategoryRes()        {}
func (*BadRequest) insightTransferNoCategoryRes()      {}
func (*BadRequest) insightTransferNoTagRes()           {}
func (*BadRequest) insightTransferTagRes()             {}
func (*BadRequest) insightTransferTotalRes()           {}
func (*BadRequest) insightTransfersRes()               {}
func (*BadRequest) listAccountByCurrencyRes()          {}
func (*BadRequest) listAccountRes()                    {}
func (*BadRequest) listAttachmentByAccountRes()        {}
func (*BadRequest) listAttachmentByBillRes()           {}
func (*BadRequest) listAttachmentByBudgetRes()         {}
func (*BadRequest) listAttachmentByCategoryRes()       {}
func (*BadRequest) listAttachmentByPiggyBankRes()      {}
func (*BadRequest) listAttachmentByTagRes()            {}
func (*BadRequest) listAttachmentByTransactionRes()    {}
func (*BadRequest) listAttachmentRes()                 {}
func (*BadRequest) listAvailableBudgetByCurrencyRes()  {}
func (*BadRequest) listAvailableBudgetRes()            {}
func (*BadRequest) listBillByCurrencyRes()             {}
func (*BadRequest) listBillByObjectGroupRes()          {}
func (*BadRequest) listBillRes()                       {}
func (*BadRequest) listBudgetLimitByBudgetRes()        {}
func (*BadRequest) listBudgetLimitByCurrencyRes()      {}
func (*BadRequest) listBudgetLimitRes()                {}
func (*BadRequest) listBudgetRes()                     {}
func (*BadRequest) listCategoryRes()                   {}
func (*BadRequest) listCurrencyRes()                   {}
func (*BadRequest) listEventByPiggyBankRes()           {}
func (*BadRequest) listEventByTransactionRes()         {}
func (*BadRequest) listLinkTypeRes()                   {}
func (*BadRequest) listLinksByJournalRes()             {}
func (*BadRequest) listObjectGroupsRes()               {}
func (*BadRequest) listPiggyBankByAccountRes()         {}
func (*BadRequest) listPiggyBankByObjectGroupRes()     {}
func (*BadRequest) listPiggyBankRes()                  {}
func (*BadRequest) listPreferenceRes()                 {}
func (*BadRequest) listRecurrenceByCurrencyRes()       {}
func (*BadRequest) listRecurrenceRes()                 {}
func (*BadRequest) listRuleByBillRes()                 {}
func (*BadRequest) listRuleByCurrencyRes()             {}
func (*BadRequest) listRuleByGroupRes()                {}
func (*BadRequest) listRuleGroupRes()                  {}
func (*BadRequest) listRuleRes()                       {}
func (*BadRequest) listTagRes()                        {}
func (*BadRequest) listTransactionByAccountRes()       {}
func (*BadRequest) listTransactionByBillRes()          {}
func (*BadRequest) listTransactionByBudgetLimitRes()   {}
func (*BadRequest) listTransactionByBudgetRes()        {}
func (*BadRequest) listTransactionByCategoryRes()      {}
func (*BadRequest) listTransactionByCurrencyRes()      {}
func (*BadRequest) listTransactionByLinkTypeRes()      {}
func (*BadRequest) listTransactionByRecurrenceRes()    {}
func (*BadRequest) listTransactionByTagRes()           {}
func (*BadRequest) listTransactionLinkRes()            {}
func (*BadRequest) listTransactionRes()                {}
func (*BadRequest) listUserRes()                       {}
func (*BadRequest) listWebhookRes()                    {}
func (*BadRequest) purgeDataRes()                      {}
func (*BadRequest) searchAccountsRes()                 {}
func (*BadRequest) searchTransactionsRes()             {}
func (*BadRequest) setConfigurationRes()               {}
func (*BadRequest) storeAccountRes()                   {}
func (*BadRequest) storeAttachmentRes()                {}
func (*BadRequest) storeBillRes()                      {}
func (*BadRequest) storeBudgetLimitRes()               {}
func (*BadRequest) storeBudgetRes()                    {}
func (*BadRequest) storeCategoryRes()                  {}
func (*BadRequest) storeCurrencyRes()                  {}
func (*BadRequest) storeLinkTypeRes()                  {}
func (*BadRequest) storePiggyBankRes()                 {}
func (*BadRequest) storePreferenceRes()                {}
func (*BadRequest) storeRecurrenceRes()                {}
func (*BadRequest) storeRuleGroupRes()                 {}
func (*BadRequest) storeRuleRes()                      {}
func (*BadRequest) storeTagRes()                       {}
func (*BadRequest) storeTransactionLinkRes()           {}
func (*BadRequest) storeTransactionRes()               {}
func (*BadRequest) storeUserRes()                      {}
func (*BadRequest) storeWebhookRes()                   {}
func (*BadRequest) testRuleGroupRes()                  {}
func (*BadRequest) testRuleRes()                       {}
func (*BadRequest) updateAccountRes()                  {}
func (*BadRequest) updateAttachmentRes()               {}
func (*BadRequest) updateBillRes()                     {}
func (*BadRequest) updateBudgetLimitRes()              {}
func (*BadRequest) updateBudgetRes()                   {}
func (*BadRequest) updateCategoryRes()                 {}
func (*BadRequest) updateCurrencyRes()                 {}
func (*BadRequest) updateLinkTypeRes()                 {}
func (*BadRequest) updateObjectGroupRes()              {}
func (*BadRequest) updatePiggyBankRes()                {}
func (*BadRequest) updatePreferenceRes()               {}
func (*BadRequest) updateRecurrenceRes()               {}
func (*BadRequest) updateRuleGroupRes()                {}
func (*BadRequest) updateRuleRes()                     {}
func (*BadRequest) updateTagRes()                      {}
func (*BadRequest) updateTransactionLinkRes()          {}
func (*BadRequest) updateTransactionRes()              {}
func (*BadRequest) updateUserRes()                     {}
func (*BadRequest) updateWebhookRes()                  {}
func (*BadRequest) uploadAttachmentRes()               {}

// Ref: #/components/schemas/BasicSummary
type BasicSummary map[string]BasicSummaryEntry

func (s *BasicSummary) init() BasicSummary {
        m := *s
        if m == nil {
                m = map[string]BasicSummaryEntry{}
                *s = m
        }
        return m
}

func (*BasicSummary) getBasicSummaryRes() {}

// Ref: #/components/schemas/BasicSummaryEntry
type BasicSummaryEntry struct {
        // This is a reference to the type of info shared, not influenced by translations or user preferences.
        //  The EUR value is a reference to the currency code. Possibilities are: balance-in-ABC,
        // spent-in-ABC, earned-in-ABC, bills-paid-in-ABC, bills-unpaid-in-ABC, left-to-spend-in-ABC and
        // net-worth-in-ABC.
        Key OptString `json:"key"`
        // A translated title for the information shared.
        Title OptString `json:"title"`
        // The amount as a float.
        MonetaryValue OptFloat64 `json:"monetary_value"`
        // The currency ID of the associated currency.
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals for the associated currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // The amount formatted according to the users locale.
        ValueParsed OptString `json:"value_parsed"`
        // Reference to a font-awesome icon without the fa- part.
        LocalIcon OptString `json:"local_icon"`
        // A short explanation of the amounts origin. Already formatted according to the locale of the user
        // or translated, if relevant.
        SubTitle OptString `json:"sub_title"`
}

// GetKey returns the value of Key.
func (s *BasicSummaryEntry) GetKey() OptString {
        return s.Key
}

// GetTitle returns the value of Title.
func (s *BasicSummaryEntry) GetTitle() OptString {
        return s.Title
}

// GetMonetaryValue returns the value of MonetaryValue.
func (s *BasicSummaryEntry) GetMonetaryValue() OptFloat64 {
        return s.MonetaryValue
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BasicSummaryEntry) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BasicSummaryEntry) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *BasicSummaryEntry) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *BasicSummaryEntry) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetValueParsed returns the value of ValueParsed.
func (s *BasicSummaryEntry) GetValueParsed() OptString {
        return s.ValueParsed
}

// GetLocalIcon returns the value of LocalIcon.
func (s *BasicSummaryEntry) GetLocalIcon() OptString {
        return s.LocalIcon
}

// GetSubTitle returns the value of SubTitle.
func (s *BasicSummaryEntry) GetSubTitle() OptString {
        return s.SubTitle
}

// SetKey sets the value of Key.
func (s *BasicSummaryEntry) SetKey(val OptString) {
        s.Key = val
}

// SetTitle sets the value of Title.
func (s *BasicSummaryEntry) SetTitle(val OptString) {
        s.Title = val
}

// SetMonetaryValue sets the value of MonetaryValue.
func (s *BasicSummaryEntry) SetMonetaryValue(val OptFloat64) {
        s.MonetaryValue = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BasicSummaryEntry) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BasicSummaryEntry) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *BasicSummaryEntry) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *BasicSummaryEntry) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetValueParsed sets the value of ValueParsed.
func (s *BasicSummaryEntry) SetValueParsed(val OptString) {
        s.ValueParsed = val
}

// SetLocalIcon sets the value of LocalIcon.
func (s *BasicSummaryEntry) SetLocalIcon(val OptString) {
        s.LocalIcon = val
}

// SetSubTitle sets the value of SubTitle.
func (s *BasicSummaryEntry) SetSubTitle(val OptString) {
        s.SubTitle = val
}

// Ref: #/components/schemas/Bill
type Bill struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // Use either currency_id or currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code.
        CurrencyCode          OptString `json:"currency_code"`
        CurrencySymbol        OptString `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        Name                  string    `json:"name"`
        AmountMin             string    `json:"amount_min"`
        AmountMax             string    `json:"amount_max"`
        Date                  time.Time `json:"date"`
        // The date after which this bill is no longer valid or applicable.
        EndDate OptDateTime `json:"end_date"`
        // The date before which the bill must be renewed (or cancelled).
        ExtensionDate OptDateTime         `json:"extension_date"`
        RepeatFreq    BillRepeatFrequency `json:"repeat_freq"`
        // How often the bill must be skipped. 1 means a bi-monthly bill.
        Skip OptInt32 `json:"skip"`
        // If the bill is active.
        Active OptBool `json:"active"`
        // Order of the bill.
        Order OptInt32     `json:"order"`
        Notes OptNilString `json:"notes"`
        // When the bill is expected to be due.
        NextExpectedMatch OptNilDateTime `json:"next_expected_match"`
        // Formatted (locally) when the bill is due.
        NextExpectedMatchDiff OptNilString `json:"next_expected_match_diff"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The order of the group. At least 1, for the highest sorting.
        ObjectGroupOrder OptNilInt32 `json:"object_group_order"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
        // Array of future dates when the bill is expected to be paid. Autogenerated.
        PayDates []time.Time `json:"pay_dates"`
        // Array of past transactions when the bill was paid.
        PaidDates []BillPaidDatesItem `json:"paid_dates"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Bill) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Bill) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetCurrencyID returns the value of CurrencyID.
func (s *Bill) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *Bill) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *Bill) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *Bill) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetName returns the value of Name.
func (s *Bill) GetName() string {
        return s.Name
}

// GetAmountMin returns the value of AmountMin.
func (s *Bill) GetAmountMin() string {
        return s.AmountMin
}

// GetAmountMax returns the value of AmountMax.
func (s *Bill) GetAmountMax() string {
        return s.AmountMax
}

// GetDate returns the value of Date.
func (s *Bill) GetDate() time.Time {
        return s.Date
}

// GetEndDate returns the value of EndDate.
func (s *Bill) GetEndDate() OptDateTime {
        return s.EndDate
}

// GetExtensionDate returns the value of ExtensionDate.
func (s *Bill) GetExtensionDate() OptDateTime {
        return s.ExtensionDate
}

// GetRepeatFreq returns the value of RepeatFreq.
func (s *Bill) GetRepeatFreq() BillRepeatFrequency {
        return s.RepeatFreq
}

// GetSkip returns the value of Skip.
func (s *Bill) GetSkip() OptInt32 {
        return s.Skip
}

// GetActive returns the value of Active.
func (s *Bill) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *Bill) GetOrder() OptInt32 {
        return s.Order
}

// GetNotes returns the value of Notes.
func (s *Bill) GetNotes() OptNilString {
        return s.Notes
}

// GetNextExpectedMatch returns the value of NextExpectedMatch.
func (s *Bill) GetNextExpectedMatch() OptNilDateTime {
        return s.NextExpectedMatch
}

// GetNextExpectedMatchDiff returns the value of NextExpectedMatchDiff.
func (s *Bill) GetNextExpectedMatchDiff() OptNilString {
        return s.NextExpectedMatchDiff
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *Bill) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupOrder returns the value of ObjectGroupOrder.
func (s *Bill) GetObjectGroupOrder() OptNilInt32 {
        return s.ObjectGroupOrder
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *Bill) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// GetPayDates returns the value of PayDates.
func (s *Bill) GetPayDates() []time.Time {
        return s.PayDates
}

// GetPaidDates returns the value of PaidDates.
func (s *Bill) GetPaidDates() []BillPaidDatesItem {
        return s.PaidDates
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Bill) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Bill) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *Bill) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *Bill) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *Bill) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *Bill) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetName sets the value of Name.
func (s *Bill) SetName(val string) {
        s.Name = val
}

// SetAmountMin sets the value of AmountMin.
func (s *Bill) SetAmountMin(val string) {
        s.AmountMin = val
}

// SetAmountMax sets the value of AmountMax.
func (s *Bill) SetAmountMax(val string) {
        s.AmountMax = val
}

// SetDate sets the value of Date.
func (s *Bill) SetDate(val time.Time) {
        s.Date = val
}

// SetEndDate sets the value of EndDate.
func (s *Bill) SetEndDate(val OptDateTime) {
        s.EndDate = val
}

// SetExtensionDate sets the value of ExtensionDate.
func (s *Bill) SetExtensionDate(val OptDateTime) {
        s.ExtensionDate = val
}

// SetRepeatFreq sets the value of RepeatFreq.
func (s *Bill) SetRepeatFreq(val BillRepeatFrequency) {
        s.RepeatFreq = val
}

// SetSkip sets the value of Skip.
func (s *Bill) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetActive sets the value of Active.
func (s *Bill) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *Bill) SetOrder(val OptInt32) {
        s.Order = val
}

// SetNotes sets the value of Notes.
func (s *Bill) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetNextExpectedMatch sets the value of NextExpectedMatch.
func (s *Bill) SetNextExpectedMatch(val OptNilDateTime) {
        s.NextExpectedMatch = val
}

// SetNextExpectedMatchDiff sets the value of NextExpectedMatchDiff.
func (s *Bill) SetNextExpectedMatchDiff(val OptNilString) {
        s.NextExpectedMatchDiff = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *Bill) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupOrder sets the value of ObjectGroupOrder.
func (s *Bill) SetObjectGroupOrder(val OptNilInt32) {
        s.ObjectGroupOrder = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *Bill) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// SetPayDates sets the value of PayDates.
func (s *Bill) SetPayDates(val []time.Time) {
        s.PayDates = val
}

// SetPaidDates sets the value of PaidDates.
func (s *Bill) SetPaidDates(val []BillPaidDatesItem) {
        s.PaidDates = val
}

// Ref: #/components/schemas/BillArray
type BillArray struct {
        Data []BillRead `json:"data"`
        Meta Meta       `json:"meta"`
}

// GetData returns the value of Data.
func (s *BillArray) GetData() []BillRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *BillArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *BillArray) SetData(val []BillRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *BillArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*BillArray) listBillByCurrencyRes()    {}
func (*BillArray) listBillByObjectGroupRes() {}
func (*BillArray) listBillRes()              {}

type BillPaidDatesItem struct {
        // Transaction group ID of the paid bill.
        TransactionGroupID OptString `json:"transaction_group_id"`
        // Transaction journal ID of the paid bill.
        TransactionJournalID OptString `json:"transaction_journal_id"`
        // Date the bill was paid.
        Date OptDateTime `json:"date"`
}

// GetTransactionGroupID returns the value of TransactionGroupID.
func (s *BillPaidDatesItem) GetTransactionGroupID() OptString {
        return s.TransactionGroupID
}

// GetTransactionJournalID returns the value of TransactionJournalID.
func (s *BillPaidDatesItem) GetTransactionJournalID() OptString {
        return s.TransactionJournalID
}

// GetDate returns the value of Date.
func (s *BillPaidDatesItem) GetDate() OptDateTime {
        return s.Date
}

// SetTransactionGroupID sets the value of TransactionGroupID.
func (s *BillPaidDatesItem) SetTransactionGroupID(val OptString) {
        s.TransactionGroupID = val
}

// SetTransactionJournalID sets the value of TransactionJournalID.
func (s *BillPaidDatesItem) SetTransactionJournalID(val OptString) {
        s.TransactionJournalID = val
}

// SetDate sets the value of Date.
func (s *BillPaidDatesItem) SetDate(val OptDateTime) {
        s.Date = val
}

// Ref: #/components/schemas/BillRead
type BillRead struct {
        // Immutable value.
        Type       string `json:"type"`
        ID         string `json:"id"`
        Attributes Bill   `json:"attributes"`
}

// GetType returns the value of Type.
func (s *BillRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *BillRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *BillRead) GetAttributes() Bill {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *BillRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *BillRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *BillRead) SetAttributes(val Bill) {
        s.Attributes = val
}

// How often the bill must be paid.
// Ref: #/components/schemas/BillRepeatFrequency
type BillRepeatFrequency string

const (
        BillRepeatFrequencyWeekly    BillRepeatFrequency = "weekly"
        BillRepeatFrequencyMonthly   BillRepeatFrequency = "monthly"
        BillRepeatFrequencyQuarterly BillRepeatFrequency = "quarterly"
        BillRepeatFrequencyHalfYear  BillRepeatFrequency = "half-year"
        BillRepeatFrequencyYearly    BillRepeatFrequency = "yearly"
)

// AllValues returns all BillRepeatFrequency values.
func (BillRepeatFrequency) AllValues() []BillRepeatFrequency {
        return []BillRepeatFrequency{
                BillRepeatFrequencyWeekly,
                BillRepeatFrequencyMonthly,
                BillRepeatFrequencyQuarterly,
                BillRepeatFrequencyHalfYear,
                BillRepeatFrequencyYearly,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s BillRepeatFrequency) MarshalText() ([]byte, error) {
        switch s {
        case BillRepeatFrequencyWeekly:
                return []byte(s), nil
        case BillRepeatFrequencyMonthly:
                return []byte(s), nil
        case BillRepeatFrequencyQuarterly:
                return []byte(s), nil
        case BillRepeatFrequencyHalfYear:
                return []byte(s), nil
        case BillRepeatFrequencyYearly:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *BillRepeatFrequency) UnmarshalText(data []byte) error {
        switch BillRepeatFrequency(data) {
        case BillRepeatFrequencyWeekly:
                *s = BillRepeatFrequencyWeekly
                return nil
        case BillRepeatFrequencyMonthly:
                *s = BillRepeatFrequencyMonthly
                return nil
        case BillRepeatFrequencyQuarterly:
                *s = BillRepeatFrequencyQuarterly
                return nil
        case BillRepeatFrequencyHalfYear:
                *s = BillRepeatFrequencyHalfYear
                return nil
        case BillRepeatFrequencyYearly:
                *s = BillRepeatFrequencyYearly
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/BillSingle
type BillSingle struct {
        Data BillRead `json:"data"`
}

// GetData returns the value of Data.
func (s *BillSingle) GetData() BillRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *BillSingle) SetData(val BillRead) {
        s.Data = val
}

func (*BillSingle) getBillRes()    {}
func (*BillSingle) storeBillRes()  {}
func (*BillSingle) updateBillRes() {}

// Ref: #/components/schemas/BillStore
type BillStore struct {
        // Use either currency_id or currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code.
        CurrencyCode OptString `json:"currency_code"`
        Name         string    `json:"name"`
        AmountMin    string    `json:"amount_min"`
        AmountMax    string    `json:"amount_max"`
        Date         time.Time `json:"date"`
        // The date after which this bill is no longer valid or applicable.
        EndDate OptDateTime `json:"end_date"`
        // The date before which the bill must be renewed (or cancelled).
        ExtensionDate OptDateTime         `json:"extension_date"`
        RepeatFreq    BillRepeatFrequency `json:"repeat_freq"`
        // How often the bill must be skipped. 1 means a bi-monthly bill.
        Skip OptInt32 `json:"skip"`
        // If the bill is active.
        Active OptBool      `json:"active"`
        Notes  OptNilString `json:"notes"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BillStore) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BillStore) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetName returns the value of Name.
func (s *BillStore) GetName() string {
        return s.Name
}

// GetAmountMin returns the value of AmountMin.
func (s *BillStore) GetAmountMin() string {
        return s.AmountMin
}

// GetAmountMax returns the value of AmountMax.
func (s *BillStore) GetAmountMax() string {
        return s.AmountMax
}

// GetDate returns the value of Date.
func (s *BillStore) GetDate() time.Time {
        return s.Date
}

// GetEndDate returns the value of EndDate.
func (s *BillStore) GetEndDate() OptDateTime {
        return s.EndDate
}

// GetExtensionDate returns the value of ExtensionDate.
func (s *BillStore) GetExtensionDate() OptDateTime {
        return s.ExtensionDate
}

// GetRepeatFreq returns the value of RepeatFreq.
func (s *BillStore) GetRepeatFreq() BillRepeatFrequency {
        return s.RepeatFreq
}

// GetSkip returns the value of Skip.
func (s *BillStore) GetSkip() OptInt32 {
        return s.Skip
}

// GetActive returns the value of Active.
func (s *BillStore) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *BillStore) GetNotes() OptNilString {
        return s.Notes
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *BillStore) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *BillStore) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BillStore) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BillStore) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetName sets the value of Name.
func (s *BillStore) SetName(val string) {
        s.Name = val
}

// SetAmountMin sets the value of AmountMin.
func (s *BillStore) SetAmountMin(val string) {
        s.AmountMin = val
}

// SetAmountMax sets the value of AmountMax.
func (s *BillStore) SetAmountMax(val string) {
        s.AmountMax = val
}

// SetDate sets the value of Date.
func (s *BillStore) SetDate(val time.Time) {
        s.Date = val
}

// SetEndDate sets the value of EndDate.
func (s *BillStore) SetEndDate(val OptDateTime) {
        s.EndDate = val
}

// SetExtensionDate sets the value of ExtensionDate.
func (s *BillStore) SetExtensionDate(val OptDateTime) {
        s.ExtensionDate = val
}

// SetRepeatFreq sets the value of RepeatFreq.
func (s *BillStore) SetRepeatFreq(val BillRepeatFrequency) {
        s.RepeatFreq = val
}

// SetSkip sets the value of Skip.
func (s *BillStore) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetActive sets the value of Active.
func (s *BillStore) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *BillStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *BillStore) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *BillStore) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// Ref: #/components/schemas/BillUpdate
type BillUpdate struct {
        // Use either currency_id or currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code.
        CurrencyCode OptString   `json:"currency_code"`
        Name         string      `json:"name"`
        AmountMin    OptString   `json:"amount_min"`
        AmountMax    OptString   `json:"amount_max"`
        Date         OptDateTime `json:"date"`
        // The date after which this bill is no longer valid or applicable.
        EndDate OptDateTime `json:"end_date"`
        // The date before which the bill must be renewed (or cancelled).
        ExtensionDate OptDateTime            `json:"extension_date"`
        RepeatFreq    OptBillRepeatFrequency `json:"repeat_freq"`
        // How often the bill must be skipped. 1 means a bi-monthly bill.
        Skip OptInt32 `json:"skip"`
        // If the bill is active.
        Active OptBool      `json:"active"`
        Notes  OptNilString `json:"notes"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BillUpdate) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BillUpdate) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetName returns the value of Name.
func (s *BillUpdate) GetName() string {
        return s.Name
}

// GetAmountMin returns the value of AmountMin.
func (s *BillUpdate) GetAmountMin() OptString {
        return s.AmountMin
}

// GetAmountMax returns the value of AmountMax.
func (s *BillUpdate) GetAmountMax() OptString {
        return s.AmountMax
}

// GetDate returns the value of Date.
func (s *BillUpdate) GetDate() OptDateTime {
        return s.Date
}

// GetEndDate returns the value of EndDate.
func (s *BillUpdate) GetEndDate() OptDateTime {
        return s.EndDate
}

// GetExtensionDate returns the value of ExtensionDate.
func (s *BillUpdate) GetExtensionDate() OptDateTime {
        return s.ExtensionDate
}

// GetRepeatFreq returns the value of RepeatFreq.
func (s *BillUpdate) GetRepeatFreq() OptBillRepeatFrequency {
        return s.RepeatFreq
}

// GetSkip returns the value of Skip.
func (s *BillUpdate) GetSkip() OptInt32 {
        return s.Skip
}

// GetActive returns the value of Active.
func (s *BillUpdate) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *BillUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *BillUpdate) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *BillUpdate) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BillUpdate) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BillUpdate) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetName sets the value of Name.
func (s *BillUpdate) SetName(val string) {
        s.Name = val
}

// SetAmountMin sets the value of AmountMin.
func (s *BillUpdate) SetAmountMin(val OptString) {
        s.AmountMin = val
}

// SetAmountMax sets the value of AmountMax.
func (s *BillUpdate) SetAmountMax(val OptString) {
        s.AmountMax = val
}

// SetDate sets the value of Date.
func (s *BillUpdate) SetDate(val OptDateTime) {
        s.Date = val
}

// SetEndDate sets the value of EndDate.
func (s *BillUpdate) SetEndDate(val OptDateTime) {
        s.EndDate = val
}

// SetExtensionDate sets the value of ExtensionDate.
func (s *BillUpdate) SetExtensionDate(val OptDateTime) {
        s.ExtensionDate = val
}

// SetRepeatFreq sets the value of RepeatFreq.
func (s *BillUpdate) SetRepeatFreq(val OptBillRepeatFrequency) {
        s.RepeatFreq = val
}

// SetSkip sets the value of Skip.
func (s *BillUpdate) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetActive sets the value of Active.
func (s *BillUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *BillUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *BillUpdate) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *BillUpdate) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// Ref: #/components/schemas/Budget
type Budget struct {
        CreatedAt      OptDateTime          `json:"created_at"`
        UpdatedAt      OptDateTime          `json:"updated_at"`
        Name           string               `json:"name"`
        Active         OptBool              `json:"active"`
        Notes          OptNilString         `json:"notes"`
        Order          OptInt32             `json:"order"`
        AutoBudgetType OptNilAutoBudgetType `json:"auto_budget_type"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyID OptNilString `json:"auto_budget_currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyCode OptNilString           `json:"auto_budget_currency_code"`
        AutoBudgetAmount       OptNilString           `json:"auto_budget_amount"`
        AutoBudgetPeriod       OptNilAutoBudgetPeriod `json:"auto_budget_period"`
        // Information on how much was spent in this budget. Is only filled in when the start and end date
        // are submitted.
        Spent []BudgetSpent `json:"spent"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Budget) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Budget) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetName returns the value of Name.
func (s *Budget) GetName() string {
        return s.Name
}

// GetActive returns the value of Active.
func (s *Budget) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *Budget) GetNotes() OptNilString {
        return s.Notes
}

// GetOrder returns the value of Order.
func (s *Budget) GetOrder() OptInt32 {
        return s.Order
}

// GetAutoBudgetType returns the value of AutoBudgetType.
func (s *Budget) GetAutoBudgetType() OptNilAutoBudgetType {
        return s.AutoBudgetType
}

// GetAutoBudgetCurrencyID returns the value of AutoBudgetCurrencyID.
func (s *Budget) GetAutoBudgetCurrencyID() OptNilString {
        return s.AutoBudgetCurrencyID
}

// GetAutoBudgetCurrencyCode returns the value of AutoBudgetCurrencyCode.
func (s *Budget) GetAutoBudgetCurrencyCode() OptNilString {
        return s.AutoBudgetCurrencyCode
}

// GetAutoBudgetAmount returns the value of AutoBudgetAmount.
func (s *Budget) GetAutoBudgetAmount() OptNilString {
        return s.AutoBudgetAmount
}

// GetAutoBudgetPeriod returns the value of AutoBudgetPeriod.
func (s *Budget) GetAutoBudgetPeriod() OptNilAutoBudgetPeriod {
        return s.AutoBudgetPeriod
}

// GetSpent returns the value of Spent.
func (s *Budget) GetSpent() []BudgetSpent {
        return s.Spent
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Budget) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Budget) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetName sets the value of Name.
func (s *Budget) SetName(val string) {
        s.Name = val
}

// SetActive sets the value of Active.
func (s *Budget) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *Budget) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetOrder sets the value of Order.
func (s *Budget) SetOrder(val OptInt32) {
        s.Order = val
}

// SetAutoBudgetType sets the value of AutoBudgetType.
func (s *Budget) SetAutoBudgetType(val OptNilAutoBudgetType) {
        s.AutoBudgetType = val
}

// SetAutoBudgetCurrencyID sets the value of AutoBudgetCurrencyID.
func (s *Budget) SetAutoBudgetCurrencyID(val OptNilString) {
        s.AutoBudgetCurrencyID = val
}

// SetAutoBudgetCurrencyCode sets the value of AutoBudgetCurrencyCode.
func (s *Budget) SetAutoBudgetCurrencyCode(val OptNilString) {
        s.AutoBudgetCurrencyCode = val
}

// SetAutoBudgetAmount sets the value of AutoBudgetAmount.
func (s *Budget) SetAutoBudgetAmount(val OptNilString) {
        s.AutoBudgetAmount = val
}

// SetAutoBudgetPeriod sets the value of AutoBudgetPeriod.
func (s *Budget) SetAutoBudgetPeriod(val OptNilAutoBudgetPeriod) {
        s.AutoBudgetPeriod = val
}

// SetSpent sets the value of Spent.
func (s *Budget) SetSpent(val []BudgetSpent) {
        s.Spent = val
}

// Ref: #/components/schemas/BudgetArray
type BudgetArray struct {
        Data []BudgetRead `json:"data"`
        Meta Meta         `json:"meta"`
}

// GetData returns the value of Data.
func (s *BudgetArray) GetData() []BudgetRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *BudgetArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *BudgetArray) SetData(val []BudgetRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *BudgetArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*BudgetArray) listBudgetRes() {}

// Ref: #/components/schemas/BudgetLimit
type BudgetLimit struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // Start date of the budget limit.
        Start time.Time `json:"start"`
        // End date of the budget limit.
        End time.Time `json:"end"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyCode          OptString `json:"currency_code"`
        CurrencyName          OptString `json:"currency_name"`
        CurrencySymbol        OptString `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32  `json:"currency_decimal_places"`
        // The budget ID of the associated budget.
        BudgetID string `json:"budget_id"`
        // Period of the budget limit. Only used when auto-generated by auto-budget.
        Period OptNilString `json:"period"`
        Amount string       `json:"amount"`
        Spent  OptNilString `json:"spent"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *BudgetLimit) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *BudgetLimit) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetStart returns the value of Start.
func (s *BudgetLimit) GetStart() time.Time {
        return s.Start
}

// GetEnd returns the value of End.
func (s *BudgetLimit) GetEnd() time.Time {
        return s.End
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BudgetLimit) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BudgetLimit) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencyName returns the value of CurrencyName.
func (s *BudgetLimit) GetCurrencyName() OptString {
        return s.CurrencyName
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *BudgetLimit) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *BudgetLimit) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetBudgetID returns the value of BudgetID.
func (s *BudgetLimit) GetBudgetID() string {
        return s.BudgetID
}

// GetPeriod returns the value of Period.
func (s *BudgetLimit) GetPeriod() OptNilString {
        return s.Period
}

// GetAmount returns the value of Amount.
func (s *BudgetLimit) GetAmount() string {
        return s.Amount
}

// GetSpent returns the value of Spent.
func (s *BudgetLimit) GetSpent() OptNilString {
        return s.Spent
}

// SetCreatedAt sets the value of CreatedAt.
func (s *BudgetLimit) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *BudgetLimit) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetStart sets the value of Start.
func (s *BudgetLimit) SetStart(val time.Time) {
        s.Start = val
}

// SetEnd sets the value of End.
func (s *BudgetLimit) SetEnd(val time.Time) {
        s.End = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BudgetLimit) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BudgetLimit) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencyName sets the value of CurrencyName.
func (s *BudgetLimit) SetCurrencyName(val OptString) {
        s.CurrencyName = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *BudgetLimit) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *BudgetLimit) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetBudgetID sets the value of BudgetID.
func (s *BudgetLimit) SetBudgetID(val string) {
        s.BudgetID = val
}

// SetPeriod sets the value of Period.
func (s *BudgetLimit) SetPeriod(val OptNilString) {
        s.Period = val
}

// SetAmount sets the value of Amount.
func (s *BudgetLimit) SetAmount(val string) {
        s.Amount = val
}

// SetSpent sets the value of Spent.
func (s *BudgetLimit) SetSpent(val OptNilString) {
        s.Spent = val
}

// Ref: #/components/schemas/BudgetLimitArray
type BudgetLimitArray struct {
        Data []BudgetLimitRead `json:"data"`
        Meta Meta              `json:"meta"`
}

// GetData returns the value of Data.
func (s *BudgetLimitArray) GetData() []BudgetLimitRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *BudgetLimitArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *BudgetLimitArray) SetData(val []BudgetLimitRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *BudgetLimitArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*BudgetLimitArray) listBudgetLimitByBudgetRes()   {}
func (*BudgetLimitArray) listBudgetLimitByCurrencyRes() {}
func (*BudgetLimitArray) listBudgetLimitRes()           {}

// Ref: #/components/schemas/BudgetLimitRead
type BudgetLimitRead struct {
        // Immutable value.
        Type       string      `json:"type"`
        ID         string      `json:"id"`
        Attributes BudgetLimit `json:"attributes"`
}

// GetType returns the value of Type.
func (s *BudgetLimitRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *BudgetLimitRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *BudgetLimitRead) GetAttributes() BudgetLimit {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *BudgetLimitRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *BudgetLimitRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *BudgetLimitRead) SetAttributes(val BudgetLimit) {
        s.Attributes = val
}

// Ref: #/components/schemas/BudgetLimitSingle
type BudgetLimitSingle struct {
        Data BudgetLimitRead `json:"data"`
}

// GetData returns the value of Data.
func (s *BudgetLimitSingle) GetData() BudgetLimitRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *BudgetLimitSingle) SetData(val BudgetLimitRead) {
        s.Data = val
}

func (*BudgetLimitSingle) getBudgetLimitRes()    {}
func (*BudgetLimitSingle) storeBudgetLimitRes()  {}
func (*BudgetLimitSingle) updateBudgetLimitRes() {}

// Ref: #/components/schemas/BudgetLimitStore
type BudgetLimitStore struct {
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyID OptString `json:"currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        CurrencyCode OptString `json:"currency_code"`
        // The budget ID of the associated budget.
        BudgetID string `json:"budget_id"`
        // Start date of the budget limit.
        Start time.Time `json:"start"`
        // Period of the budget limit. Only used when auto-generated by auto-budget.
        Period OptNilString `json:"period"`
        // End date of the budget limit.
        End    time.Time `json:"end"`
        Amount string    `json:"amount"`
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BudgetLimitStore) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BudgetLimitStore) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetBudgetID returns the value of BudgetID.
func (s *BudgetLimitStore) GetBudgetID() string {
        return s.BudgetID
}

// GetStart returns the value of Start.
func (s *BudgetLimitStore) GetStart() time.Time {
        return s.Start
}

// GetPeriod returns the value of Period.
func (s *BudgetLimitStore) GetPeriod() OptNilString {
        return s.Period
}

// GetEnd returns the value of End.
func (s *BudgetLimitStore) GetEnd() time.Time {
        return s.End
}

// GetAmount returns the value of Amount.
func (s *BudgetLimitStore) GetAmount() string {
        return s.Amount
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BudgetLimitStore) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BudgetLimitStore) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetBudgetID sets the value of BudgetID.
func (s *BudgetLimitStore) SetBudgetID(val string) {
        s.BudgetID = val
}

// SetStart sets the value of Start.
func (s *BudgetLimitStore) SetStart(val time.Time) {
        s.Start = val
}

// SetPeriod sets the value of Period.
func (s *BudgetLimitStore) SetPeriod(val OptNilString) {
        s.Period = val
}

// SetEnd sets the value of End.
func (s *BudgetLimitStore) SetEnd(val time.Time) {
        s.End = val
}

// SetAmount sets the value of Amount.
func (s *BudgetLimitStore) SetAmount(val string) {
        s.Amount = val
}

// Ref: #/components/schemas/BudgetRead
type BudgetRead struct {
        // Immutable value.
        Type       string `json:"type"`
        ID         string `json:"id"`
        Attributes Budget `json:"attributes"`
}

// GetType returns the value of Type.
func (s *BudgetRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *BudgetRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *BudgetRead) GetAttributes() Budget {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *BudgetRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *BudgetRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *BudgetRead) SetAttributes(val Budget) {
        s.Attributes = val
}

// Ref: #/components/schemas/BudgetSingle
type BudgetSingle struct {
        Data BudgetRead `json:"data"`
}

// GetData returns the value of Data.
func (s *BudgetSingle) GetData() BudgetRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *BudgetSingle) SetData(val BudgetRead) {
        s.Data = val
}

func (*BudgetSingle) getBudgetRes()    {}
func (*BudgetSingle) storeBudgetRes()  {}
func (*BudgetSingle) updateBudgetRes() {}

// Ref: #/components/schemas/BudgetSpent
type BudgetSpent struct {
        // The amount spent.
        Sum            OptString `json:"sum"`
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals supported by the currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
}

// GetSum returns the value of Sum.
func (s *BudgetSpent) GetSum() OptString {
        return s.Sum
}

// GetCurrencyID returns the value of CurrencyID.
func (s *BudgetSpent) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *BudgetSpent) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *BudgetSpent) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *BudgetSpent) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// SetSum sets the value of Sum.
func (s *BudgetSpent) SetSum(val OptString) {
        s.Sum = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *BudgetSpent) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *BudgetSpent) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *BudgetSpent) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *BudgetSpent) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// Ref: #/components/schemas/BudgetStore
type BudgetStore struct {
        Name           string               `json:"name"`
        Active         OptBool              `json:"active"`
        Order          OptInt32             `json:"order"`
        Notes          OptNilString         `json:"notes"`
        AutoBudgetType OptNilAutoBudgetType `json:"auto_budget_type"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyID OptNilString `json:"auto_budget_currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyCode OptNilString           `json:"auto_budget_currency_code"`
        AutoBudgetAmount       OptNilString           `json:"auto_budget_amount"`
        AutoBudgetPeriod       OptNilAutoBudgetPeriod `json:"auto_budget_period"`
}

// GetName returns the value of Name.
func (s *BudgetStore) GetName() string {
        return s.Name
}

// GetActive returns the value of Active.
func (s *BudgetStore) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *BudgetStore) GetOrder() OptInt32 {
        return s.Order
}

// GetNotes returns the value of Notes.
func (s *BudgetStore) GetNotes() OptNilString {
        return s.Notes
}

// GetAutoBudgetType returns the value of AutoBudgetType.
func (s *BudgetStore) GetAutoBudgetType() OptNilAutoBudgetType {
        return s.AutoBudgetType
}

// GetAutoBudgetCurrencyID returns the value of AutoBudgetCurrencyID.
func (s *BudgetStore) GetAutoBudgetCurrencyID() OptNilString {
        return s.AutoBudgetCurrencyID
}

// GetAutoBudgetCurrencyCode returns the value of AutoBudgetCurrencyCode.
func (s *BudgetStore) GetAutoBudgetCurrencyCode() OptNilString {
        return s.AutoBudgetCurrencyCode
}

// GetAutoBudgetAmount returns the value of AutoBudgetAmount.
func (s *BudgetStore) GetAutoBudgetAmount() OptNilString {
        return s.AutoBudgetAmount
}

// GetAutoBudgetPeriod returns the value of AutoBudgetPeriod.
func (s *BudgetStore) GetAutoBudgetPeriod() OptNilAutoBudgetPeriod {
        return s.AutoBudgetPeriod
}

// SetName sets the value of Name.
func (s *BudgetStore) SetName(val string) {
        s.Name = val
}

// SetActive sets the value of Active.
func (s *BudgetStore) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *BudgetStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetNotes sets the value of Notes.
func (s *BudgetStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetAutoBudgetType sets the value of AutoBudgetType.
func (s *BudgetStore) SetAutoBudgetType(val OptNilAutoBudgetType) {
        s.AutoBudgetType = val
}

// SetAutoBudgetCurrencyID sets the value of AutoBudgetCurrencyID.
func (s *BudgetStore) SetAutoBudgetCurrencyID(val OptNilString) {
        s.AutoBudgetCurrencyID = val
}

// SetAutoBudgetCurrencyCode sets the value of AutoBudgetCurrencyCode.
func (s *BudgetStore) SetAutoBudgetCurrencyCode(val OptNilString) {
        s.AutoBudgetCurrencyCode = val
}

// SetAutoBudgetAmount sets the value of AutoBudgetAmount.
func (s *BudgetStore) SetAutoBudgetAmount(val OptNilString) {
        s.AutoBudgetAmount = val
}

// SetAutoBudgetPeriod sets the value of AutoBudgetPeriod.
func (s *BudgetStore) SetAutoBudgetPeriod(val OptNilAutoBudgetPeriod) {
        s.AutoBudgetPeriod = val
}

// Ref: #/components/schemas/BudgetUpdate
type BudgetUpdate struct {
        Name           string               `json:"name"`
        Active         OptBool              `json:"active"`
        Order          OptInt32             `json:"order"`
        Notes          OptNilString         `json:"notes"`
        AutoBudgetType OptNilAutoBudgetType `json:"auto_budget_type"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyID OptNilString `json:"auto_budget_currency_id"`
        // Use either currency_id or currency_code. Defaults to the user's default currency.
        AutoBudgetCurrencyCode OptNilString           `json:"auto_budget_currency_code"`
        AutoBudgetAmount       OptNilString           `json:"auto_budget_amount"`
        AutoBudgetPeriod       OptNilAutoBudgetPeriod `json:"auto_budget_period"`
}

// GetName returns the value of Name.
func (s *BudgetUpdate) GetName() string {
        return s.Name
}

// GetActive returns the value of Active.
func (s *BudgetUpdate) GetActive() OptBool {
        return s.Active
}

// GetOrder returns the value of Order.
func (s *BudgetUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetNotes returns the value of Notes.
func (s *BudgetUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetAutoBudgetType returns the value of AutoBudgetType.
func (s *BudgetUpdate) GetAutoBudgetType() OptNilAutoBudgetType {
        return s.AutoBudgetType
}

// GetAutoBudgetCurrencyID returns the value of AutoBudgetCurrencyID.
func (s *BudgetUpdate) GetAutoBudgetCurrencyID() OptNilString {
        return s.AutoBudgetCurrencyID
}

// GetAutoBudgetCurrencyCode returns the value of AutoBudgetCurrencyCode.
func (s *BudgetUpdate) GetAutoBudgetCurrencyCode() OptNilString {
        return s.AutoBudgetCurrencyCode
}

// GetAutoBudgetAmount returns the value of AutoBudgetAmount.
func (s *BudgetUpdate) GetAutoBudgetAmount() OptNilString {
        return s.AutoBudgetAmount
}

// GetAutoBudgetPeriod returns the value of AutoBudgetPeriod.
func (s *BudgetUpdate) GetAutoBudgetPeriod() OptNilAutoBudgetPeriod {
        return s.AutoBudgetPeriod
}

// SetName sets the value of Name.
func (s *BudgetUpdate) SetName(val string) {
        s.Name = val
}

// SetActive sets the value of Active.
func (s *BudgetUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetOrder sets the value of Order.
func (s *BudgetUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetNotes sets the value of Notes.
func (s *BudgetUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetAutoBudgetType sets the value of AutoBudgetType.
func (s *BudgetUpdate) SetAutoBudgetType(val OptNilAutoBudgetType) {
        s.AutoBudgetType = val
}

// SetAutoBudgetCurrencyID sets the value of AutoBudgetCurrencyID.
func (s *BudgetUpdate) SetAutoBudgetCurrencyID(val OptNilString) {
        s.AutoBudgetCurrencyID = val
}

// SetAutoBudgetCurrencyCode sets the value of AutoBudgetCurrencyCode.
func (s *BudgetUpdate) SetAutoBudgetCurrencyCode(val OptNilString) {
        s.AutoBudgetCurrencyCode = val
}

// SetAutoBudgetAmount sets the value of AutoBudgetAmount.
func (s *BudgetUpdate) SetAutoBudgetAmount(val OptNilString) {
        s.AutoBudgetAmount = val
}

// SetAutoBudgetPeriod sets the value of AutoBudgetPeriod.
func (s *BudgetUpdate) SetAutoBudgetPeriod(val OptNilAutoBudgetPeriod) {
        s.AutoBudgetPeriod = val
}

// BulkUpdateTransactionsNoContent is response for BulkUpdateTransactions operation.
type BulkUpdateTransactionsNoContent struct{}

func (*BulkUpdateTransactionsNoContent) bulkUpdateTransactionsRes() {}

// Ref: #/components/schemas/Category
type Category struct {
        CreatedAt OptDateTime      `json:"created_at"`
        UpdatedAt OptDateTime      `json:"updated_at"`
        Name      string           `json:"name"`
        Notes     OptNilString     `json:"notes"`
        Spent     []CategorySpent  `json:"spent"`
        Earned    []CategoryEarned `json:"earned"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Category) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Category) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetName returns the value of Name.
func (s *Category) GetName() string {
        return s.Name
}

// GetNotes returns the value of Notes.
func (s *Category) GetNotes() OptNilString {
        return s.Notes
}

// GetSpent returns the value of Spent.
func (s *Category) GetSpent() []CategorySpent {
        return s.Spent
}

// GetEarned returns the value of Earned.
func (s *Category) GetEarned() []CategoryEarned {
        return s.Earned
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Category) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Category) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetName sets the value of Name.
func (s *Category) SetName(val string) {
        s.Name = val
}

// SetNotes sets the value of Notes.
func (s *Category) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetSpent sets the value of Spent.
func (s *Category) SetSpent(val []CategorySpent) {
        s.Spent = val
}

// SetEarned sets the value of Earned.
func (s *Category) SetEarned(val []CategoryEarned) {
        s.Earned = val
}

// Ref: #/components/schemas/CategoryArray
type CategoryArray struct {
        Data []CategoryRead `json:"data"`
        Meta Meta           `json:"meta"`
}

// GetData returns the value of Data.
func (s *CategoryArray) GetData() []CategoryRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *CategoryArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *CategoryArray) SetData(val []CategoryRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *CategoryArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*CategoryArray) listCategoryRes() {}

// Ref: #/components/schemas/CategoryEarned
type CategoryEarned struct {
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals supported by the currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // The amount earned.
        Sum OptString `json:"sum"`
}

// GetCurrencyID returns the value of CurrencyID.
func (s *CategoryEarned) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *CategoryEarned) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *CategoryEarned) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *CategoryEarned) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetSum returns the value of Sum.
func (s *CategoryEarned) GetSum() OptString {
        return s.Sum
}

// SetCurrencyID sets the value of CurrencyID.
func (s *CategoryEarned) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *CategoryEarned) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *CategoryEarned) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *CategoryEarned) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetSum sets the value of Sum.
func (s *CategoryEarned) SetSum(val OptString) {
        s.Sum = val
}

// Ref: #/components/schemas/CategoryRead
type CategoryRead struct {
        // Immutable value.
        Type       string   `json:"type"`
        ID         string   `json:"id"`
        Attributes Category `json:"attributes"`
}

// GetType returns the value of Type.
func (s *CategoryRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *CategoryRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *CategoryRead) GetAttributes() Category {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *CategoryRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *CategoryRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *CategoryRead) SetAttributes(val Category) {
        s.Attributes = val
}

// Ref: #/components/schemas/CategorySingle
type CategorySingle struct {
        Data CategoryRead `json:"data"`
}

// GetData returns the value of Data.
func (s *CategorySingle) GetData() CategoryRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *CategorySingle) SetData(val CategoryRead) {
        s.Data = val
}

func (*CategorySingle) getCategoryRes()    {}
func (*CategorySingle) storeCategoryRes()  {}
func (*CategorySingle) updateCategoryRes() {}

// Ref: #/components/schemas/CategorySpent
type CategorySpent struct {
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals supported by the currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // The amount spent.
        Sum OptString `json:"sum"`
}

// GetCurrencyID returns the value of CurrencyID.
func (s *CategorySpent) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *CategorySpent) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *CategorySpent) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *CategorySpent) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetSum returns the value of Sum.
func (s *CategorySpent) GetSum() OptString {
        return s.Sum
}

// SetCurrencyID sets the value of CurrencyID.
func (s *CategorySpent) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *CategorySpent) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *CategorySpent) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *CategorySpent) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetSum sets the value of Sum.
func (s *CategorySpent) SetSum(val OptString) {
        s.Sum = val
}

// Ref: #/components/schemas/CategoryUpdate
type CategoryUpdate struct {
        Name  string       `json:"name"`
        Notes OptNilString `json:"notes"`
}

// GetName returns the value of Name.
func (s *CategoryUpdate) GetName() string {
        return s.Name
}

// GetNotes returns the value of Notes.
func (s *CategoryUpdate) GetNotes() OptNilString {
        return s.Notes
}

// SetName sets the value of Name.
func (s *CategoryUpdate) SetName(val string) {
        s.Name = val
}

// SetNotes sets the value of Notes.
func (s *CategoryUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// Ref: #/components/schemas/ChartDataPoint
type ChartDataPoint struct {
        // The key is the label of the value, so for example: '2018-01-01' => 13 or 'Groceries' => -123.
        Key OptString `json:"key"`
}

// GetKey returns the value of Key.
func (s *ChartDataPoint) GetKey() OptString {
        return s.Key
}

// SetKey sets the value of Key.
func (s *ChartDataPoint) SetKey(val OptString) {
        s.Key = val
}

// Ref: #/components/schemas/ChartDataSet
type ChartDataSet struct {
        // This is the title of the current set. It can refer to an account, a budget or another object (by
        // name).
        Label OptString `json:"label"`
        // The currency ID of the currency associated to the data in the entries.
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals for the currency associated to the data in the entries.
        CurrencyDecimalPlaces OptInt32    `json:"currency_decimal_places"`
        StartDate             OptDateTime `json:"start_date"`
        EndDate               OptDateTime `json:"end_date"`
        // Indicated the type of chart that is expected to be rendered. You can safely ignore this if you
        // want.
        Type OptString `json:"type"`
        // Used to indicate the Y axis for this data set. Is usually between 0 and 1 (left and right side of
        // the chart).
        YAxisID OptInt32 `json:"yAxisID"`
        // The actual entries for this data set. They 'key' value is the label for the data point. The value
        // is the actual (numerical) value.
        Entries OptChartDataSetEntries `json:"entries"`
}

// GetLabel returns the value of Label.
func (s *ChartDataSet) GetLabel() OptString {
        return s.Label
}

// GetCurrencyID returns the value of CurrencyID.
func (s *ChartDataSet) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *ChartDataSet) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *ChartDataSet) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *ChartDataSet) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetStartDate returns the value of StartDate.
func (s *ChartDataSet) GetStartDate() OptDateTime {
        return s.StartDate
}

// GetEndDate returns the value of EndDate.
func (s *ChartDataSet) GetEndDate() OptDateTime {
        return s.EndDate
}

// GetType returns the value of Type.
func (s *ChartDataSet) GetType() OptString {
        return s.Type
}

// GetYAxisID returns the value of YAxisID.
func (s *ChartDataSet) GetYAxisID() OptInt32 {
        return s.YAxisID
}

// GetEntries returns the value of Entries.
func (s *ChartDataSet) GetEntries() OptChartDataSetEntries {
        return s.Entries
}

// SetLabel sets the value of Label.
func (s *ChartDataSet) SetLabel(val OptString) {
        s.Label = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *ChartDataSet) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *ChartDataSet) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *ChartDataSet) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *ChartDataSet) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetStartDate sets the value of StartDate.
func (s *ChartDataSet) SetStartDate(val OptDateTime) {
        s.StartDate = val
}

// SetEndDate sets the value of EndDate.
func (s *ChartDataSet) SetEndDate(val OptDateTime) {
        s.EndDate = val
}

// SetType sets the value of Type.
func (s *ChartDataSet) SetType(val OptString) {
        s.Type = val
}

// SetYAxisID sets the value of YAxisID.
func (s *ChartDataSet) SetYAxisID(val OptInt32) {
        s.YAxisID = val
}

// SetEntries sets the value of Entries.
func (s *ChartDataSet) SetEntries(val OptChartDataSetEntries) {
        s.Entries = val
}

// The actual entries for this data set. They 'key' value is the label for the data point. The value
// is the actual (numerical) value.
type ChartDataSetEntries map[string]ChartDataPoint

func (s *ChartDataSetEntries) init() ChartDataSetEntries {
        m := *s
        if m == nil {
                m = map[string]ChartDataPoint{}
                *s = m
        }
        return m
}

type ChartLine []ChartDataSet

func (*ChartLine) getChartAccountOverviewRes() {}

// Ref: #/components/schemas/ConfigValueFilter
type ConfigValueFilter string

const (
        ConfigValueFilterConfigurationIsDemoSite            ConfigValueFilter = "configuration.is_demo_site"
        ConfigValueFilterConfigurationPermissionUpdateCheck ConfigValueFilter = "configuration.permission_update_check"
        ConfigValueFilterConfigurationLastUpdateCheck       ConfigValueFilter = "configuration.last_update_check"
        ConfigValueFilterConfigurationSingleUserMode        ConfigValueFilter = "configuration.single_user_mode"
        ConfigValueFilterFireflyVersion                     ConfigValueFilter = "firefly.version"
        ConfigValueFilterFireflyAPIVersion                  ConfigValueFilter = "firefly.api_version"
        ConfigValueFilterFireflyDefaultLocation             ConfigValueFilter = "firefly.default_location"
        ConfigValueFilterFireflyAccountToTransaction        ConfigValueFilter = "firefly.account_to_transaction"
        ConfigValueFilterFireflyAllowedOpposingTypes        ConfigValueFilter = "firefly.allowed_opposing_types"
        ConfigValueFilterFireflyAccountRoles                ConfigValueFilter = "firefly.accountRoles"
        ConfigValueFilterFireflyValidLiabilities            ConfigValueFilter = "firefly.valid_liabilities"
        ConfigValueFilterFireflyInterestPeriods             ConfigValueFilter = "firefly.interest_periods"
        ConfigValueFilterFireflyEnableExternalMap           ConfigValueFilter = "firefly.enable_external_map"
        ConfigValueFilterFireflyExpectedSourceTypes         ConfigValueFilter = "firefly.expected_source_types"
        ConfigValueFilterAppTimezone                        ConfigValueFilter = "app.timezone"
        ConfigValueFilterFireflyBillPeriods                 ConfigValueFilter = "firefly.bill_periods"
        ConfigValueFilterFireflyCreditCardTypes             ConfigValueFilter = "firefly.credit_card_types"
        ConfigValueFilterFireflyLanguages                   ConfigValueFilter = "firefly.languages"
        ConfigValueFilterFireflyValidViewRanges             ConfigValueFilter = "firefly.valid_view_ranges"
)

// AllValues returns all ConfigValueFilter values.
func (ConfigValueFilter) AllValues() []ConfigValueFilter {
        return []ConfigValueFilter{
                ConfigValueFilterConfigurationIsDemoSite,
                ConfigValueFilterConfigurationPermissionUpdateCheck,
                ConfigValueFilterConfigurationLastUpdateCheck,
                ConfigValueFilterConfigurationSingleUserMode,
                ConfigValueFilterFireflyVersion,
                ConfigValueFilterFireflyAPIVersion,
                ConfigValueFilterFireflyDefaultLocation,
                ConfigValueFilterFireflyAccountToTransaction,
                ConfigValueFilterFireflyAllowedOpposingTypes,
                ConfigValueFilterFireflyAccountRoles,
                ConfigValueFilterFireflyValidLiabilities,
                ConfigValueFilterFireflyInterestPeriods,
                ConfigValueFilterFireflyEnableExternalMap,
                ConfigValueFilterFireflyExpectedSourceTypes,
                ConfigValueFilterAppTimezone,
                ConfigValueFilterFireflyBillPeriods,
                ConfigValueFilterFireflyCreditCardTypes,
                ConfigValueFilterFireflyLanguages,
                ConfigValueFilterFireflyValidViewRanges,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s ConfigValueFilter) MarshalText() ([]byte, error) {
        switch s {
        case ConfigValueFilterConfigurationIsDemoSite:
                return []byte(s), nil
        case ConfigValueFilterConfigurationPermissionUpdateCheck:
                return []byte(s), nil
        case ConfigValueFilterConfigurationLastUpdateCheck:
                return []byte(s), nil
        case ConfigValueFilterConfigurationSingleUserMode:
                return []byte(s), nil
        case ConfigValueFilterFireflyVersion:
                return []byte(s), nil
        case ConfigValueFilterFireflyAPIVersion:
                return []byte(s), nil
        case ConfigValueFilterFireflyDefaultLocation:
                return []byte(s), nil
        case ConfigValueFilterFireflyAccountToTransaction:
                return []byte(s), nil
        case ConfigValueFilterFireflyAllowedOpposingTypes:
                return []byte(s), nil
        case ConfigValueFilterFireflyAccountRoles:
                return []byte(s), nil
        case ConfigValueFilterFireflyValidLiabilities:
                return []byte(s), nil
        case ConfigValueFilterFireflyInterestPeriods:
                return []byte(s), nil
        case ConfigValueFilterFireflyEnableExternalMap:
                return []byte(s), nil
        case ConfigValueFilterFireflyExpectedSourceTypes:
                return []byte(s), nil
        case ConfigValueFilterAppTimezone:
                return []byte(s), nil
        case ConfigValueFilterFireflyBillPeriods:
                return []byte(s), nil
        case ConfigValueFilterFireflyCreditCardTypes:
                return []byte(s), nil
        case ConfigValueFilterFireflyLanguages:
                return []byte(s), nil
        case ConfigValueFilterFireflyValidViewRanges:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *ConfigValueFilter) UnmarshalText(data []byte) error {
        switch ConfigValueFilter(data) {
        case ConfigValueFilterConfigurationIsDemoSite:
                *s = ConfigValueFilterConfigurationIsDemoSite
                return nil
        case ConfigValueFilterConfigurationPermissionUpdateCheck:
                *s = ConfigValueFilterConfigurationPermissionUpdateCheck
                return nil
        case ConfigValueFilterConfigurationLastUpdateCheck:
                *s = ConfigValueFilterConfigurationLastUpdateCheck
                return nil
        case ConfigValueFilterConfigurationSingleUserMode:
                *s = ConfigValueFilterConfigurationSingleUserMode
                return nil
        case ConfigValueFilterFireflyVersion:
                *s = ConfigValueFilterFireflyVersion
                return nil
        case ConfigValueFilterFireflyAPIVersion:
                *s = ConfigValueFilterFireflyAPIVersion
                return nil
        case ConfigValueFilterFireflyDefaultLocation:
                *s = ConfigValueFilterFireflyDefaultLocation
                return nil
        case ConfigValueFilterFireflyAccountToTransaction:
                *s = ConfigValueFilterFireflyAccountToTransaction
                return nil
        case ConfigValueFilterFireflyAllowedOpposingTypes:
                *s = ConfigValueFilterFireflyAllowedOpposingTypes
                return nil
        case ConfigValueFilterFireflyAccountRoles:
                *s = ConfigValueFilterFireflyAccountRoles
                return nil
        case ConfigValueFilterFireflyValidLiabilities:
                *s = ConfigValueFilterFireflyValidLiabilities
                return nil
        case ConfigValueFilterFireflyInterestPeriods:
                *s = ConfigValueFilterFireflyInterestPeriods
                return nil
        case ConfigValueFilterFireflyEnableExternalMap:
                *s = ConfigValueFilterFireflyEnableExternalMap
                return nil
        case ConfigValueFilterFireflyExpectedSourceTypes:
                *s = ConfigValueFilterFireflyExpectedSourceTypes
                return nil
        case ConfigValueFilterAppTimezone:
                *s = ConfigValueFilterAppTimezone
                return nil
        case ConfigValueFilterFireflyBillPeriods:
                *s = ConfigValueFilterFireflyBillPeriods
                return nil
        case ConfigValueFilterFireflyCreditCardTypes:
                *s = ConfigValueFilterFireflyCreditCardTypes
                return nil
        case ConfigValueFilterFireflyLanguages:
                *s = ConfigValueFilterFireflyLanguages
                return nil
        case ConfigValueFilterFireflyValidViewRanges:
                *s = ConfigValueFilterFireflyValidViewRanges
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/ConfigValueUpdateFilter
type ConfigValueUpdateFilter string

const (
        ConfigValueUpdateFilterConfigurationIsDemoSite            ConfigValueUpdateFilter = "configuration.is_demo_site"
        ConfigValueUpdateFilterConfigurationPermissionUpdateCheck ConfigValueUpdateFilter = "configuration.permission_update_check"
        ConfigValueUpdateFilterConfigurationLastUpdateCheck       ConfigValueUpdateFilter = "configuration.last_update_check"
        ConfigValueUpdateFilterConfigurationSingleUserMode        ConfigValueUpdateFilter = "configuration.single_user_mode"
)

// AllValues returns all ConfigValueUpdateFilter values.
func (ConfigValueUpdateFilter) AllValues() []ConfigValueUpdateFilter {
        return []ConfigValueUpdateFilter{
                ConfigValueUpdateFilterConfigurationIsDemoSite,
                ConfigValueUpdateFilterConfigurationPermissionUpdateCheck,
                ConfigValueUpdateFilterConfigurationLastUpdateCheck,
                ConfigValueUpdateFilterConfigurationSingleUserMode,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s ConfigValueUpdateFilter) MarshalText() ([]byte, error) {
        switch s {
        case ConfigValueUpdateFilterConfigurationIsDemoSite:
                return []byte(s), nil
        case ConfigValueUpdateFilterConfigurationPermissionUpdateCheck:
                return []byte(s), nil
        case ConfigValueUpdateFilterConfigurationLastUpdateCheck:
                return []byte(s), nil
        case ConfigValueUpdateFilterConfigurationSingleUserMode:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *ConfigValueUpdateFilter) UnmarshalText(data []byte) error {
        switch ConfigValueUpdateFilter(data) {
        case ConfigValueUpdateFilterConfigurationIsDemoSite:
                *s = ConfigValueUpdateFilterConfigurationIsDemoSite
                return nil
        case ConfigValueUpdateFilterConfigurationPermissionUpdateCheck:
                *s = ConfigValueUpdateFilterConfigurationPermissionUpdateCheck
                return nil
        case ConfigValueUpdateFilterConfigurationLastUpdateCheck:
                *s = ConfigValueUpdateFilterConfigurationLastUpdateCheck
                return nil
        case ConfigValueUpdateFilterConfigurationSingleUserMode:
                *s = ConfigValueUpdateFilterConfigurationSingleUserMode
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/Configuration
type Configuration struct {
        // Title of the configuration value.
        Title ConfigValueFilter `json:"title"`
        // Content of the configuration variable. Is very dynamic and can be anything from booleans to arrays.
        Value PolymorphicProperty `json:"value"`
        // If this config variable can be edited by the user.
        Editable bool `json:"editable"`
}

// GetTitle returns the value of Title.
func (s *Configuration) GetTitle() ConfigValueFilter {
        return s.Title
}

// GetValue returns the value of Value.
func (s *Configuration) GetValue() PolymorphicProperty {
        return s.Value
}

// GetEditable returns the value of Editable.
func (s *Configuration) GetEditable() bool {
        return s.Editable
}

// SetTitle sets the value of Title.
func (s *Configuration) SetTitle(val ConfigValueFilter) {
        s.Title = val
}

// SetValue sets the value of Value.
func (s *Configuration) SetValue(val PolymorphicProperty) {
        s.Value = val
}

// SetEditable sets the value of Editable.
func (s *Configuration) SetEditable(val bool) {
        s.Editable = val
}

type ConfigurationArray []Configuration

func (*ConfigurationArray) getConfigurationRes() {}

// Ref: #/components/schemas/ConfigurationSingle
type ConfigurationSingle struct {
        Data Configuration `json:"data"`
}

// GetData returns the value of Data.
func (s *ConfigurationSingle) GetData() Configuration {
        return s.Data
}

// SetData sets the value of Data.
func (s *ConfigurationSingle) SetData(val Configuration) {
        s.Data = val
}

func (*ConfigurationSingle) getSingleConfigurationRes() {}
func (*ConfigurationSingle) setConfigurationRes()       {}

// Ref: #/components/schemas/ConfigurationUpdate
type ConfigurationUpdate struct {
        // Can be a number, a string, boolean or object. This depends on the actual configuration value.
        Value PolymorphicProperty `json:"value"`
}

// GetValue returns the value of Value.
func (s *ConfigurationUpdate) GetValue() PolymorphicProperty {
        return s.Value
}

// SetValue sets the value of Value.
func (s *ConfigurationUpdate) SetValue(val PolymorphicProperty) {
        s.Value = val
}

// Mandatory when the account_role is ccAsset. Can only be monthlyFull or null.
// Ref: #/components/schemas/CreditCardType
type CreditCardType string

const (
        CreditCardTypeMonthlyFull CreditCardType = "monthlyFull"
)

// AllValues returns all CreditCardType values.
func (CreditCardType) AllValues() []CreditCardType {
        return []CreditCardType{
                CreditCardTypeMonthlyFull,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s CreditCardType) MarshalText() ([]byte, error) {
        switch s {
        case CreditCardTypeMonthlyFull:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *CreditCardType) UnmarshalText(data []byte) error {
        switch CreditCardType(data) {
        case CreditCardTypeMonthlyFull:
                *s = CreditCardTypeMonthlyFull
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/CronResult
type CronResult struct {
        RecurringTransactions OptCronResultRow `json:"recurring_transactions"`
        AutoBudgets           OptCronResultRow `json:"auto_budgets"`
        Telemetry             OptCronResultRow `json:"telemetry"`
}

// GetRecurringTransactions returns the value of RecurringTransactions.
func (s *CronResult) GetRecurringTransactions() OptCronResultRow {
        return s.RecurringTransactions
}

// GetAutoBudgets returns the value of AutoBudgets.
func (s *CronResult) GetAutoBudgets() OptCronResultRow {
        return s.AutoBudgets
}

// GetTelemetry returns the value of Telemetry.
func (s *CronResult) GetTelemetry() OptCronResultRow {
        return s.Telemetry
}

// SetRecurringTransactions sets the value of RecurringTransactions.
func (s *CronResult) SetRecurringTransactions(val OptCronResultRow) {
        s.RecurringTransactions = val
}

// SetAutoBudgets sets the value of AutoBudgets.
func (s *CronResult) SetAutoBudgets(val OptCronResultRow) {
        s.AutoBudgets = val
}

// SetTelemetry sets the value of Telemetry.
func (s *CronResult) SetTelemetry(val OptCronResultRow) {
        s.Telemetry = val
}

func (*CronResult) getCronRes() {}

// Ref: #/components/schemas/CronResultRow
type CronResultRow struct {
        // This value tells you if this specific cron job actually fired. It may not fire. Some cron jobs
        // only fire every 24 hours, for example.
        JobFired OptNilBool `json:"job_fired"`
        // This value tells you if this specific cron job actually did something. The job may fire but not
        // change anything.
        JobSucceeded OptNilBool `json:"job_succeeded"`
        // If the cron jobs ran into some kind of an error, this value will be true.
        JobErrored OptNilBool `json:"job_errored"`
        // If the cron job ran into some kind of an error, this value will be the error message. The success
        // message
        // if the job actually ran OK.
        Message OptNilString `json:"message"`
}

// GetJobFired returns the value of JobFired.
func (s *CronResultRow) GetJobFired() OptNilBool {
        return s.JobFired
}

// GetJobSucceeded returns the value of JobSucceeded.
func (s *CronResultRow) GetJobSucceeded() OptNilBool {
        return s.JobSucceeded
}

// GetJobErrored returns the value of JobErrored.
func (s *CronResultRow) GetJobErrored() OptNilBool {
        return s.JobErrored
}

// GetMessage returns the value of Message.
func (s *CronResultRow) GetMessage() OptNilString {
        return s.Message
}

// SetJobFired sets the value of JobFired.
func (s *CronResultRow) SetJobFired(val OptNilBool) {
        s.JobFired = val
}

// SetJobSucceeded sets the value of JobSucceeded.
func (s *CronResultRow) SetJobSucceeded(val OptNilBool) {
        s.JobSucceeded = val
}

// SetJobErrored sets the value of JobErrored.
func (s *CronResultRow) SetJobErrored(val OptNilBool) {
        s.JobErrored = val
}

// SetMessage sets the value of Message.
func (s *CronResultRow) SetMessage(val OptNilString) {
        s.Message = val
}

// Ref: #/components/schemas/Currency
type Currency struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // Defaults to true.
        Enabled OptBool `json:"enabled"`
        // Make this currency the default currency.
        Default OptBool `json:"default"`
        Code    string  `json:"code"`
        Name    string  `json:"name"`
        Symbol  string  `json:"symbol"`
        // Supports 0-16 decimals.
        DecimalPlaces OptInt32 `json:"decimal_places"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Currency) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Currency) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetEnabled returns the value of Enabled.
func (s *Currency) GetEnabled() OptBool {
        return s.Enabled
}

// GetDefault returns the value of Default.
func (s *Currency) GetDefault() OptBool {
        return s.Default
}

// GetCode returns the value of Code.
func (s *Currency) GetCode() string {
        return s.Code
}

// GetName returns the value of Name.
func (s *Currency) GetName() string {
        return s.Name
}

// GetSymbol returns the value of Symbol.
func (s *Currency) GetSymbol() string {
        return s.Symbol
}

// GetDecimalPlaces returns the value of DecimalPlaces.
func (s *Currency) GetDecimalPlaces() OptInt32 {
        return s.DecimalPlaces
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Currency) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Currency) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetEnabled sets the value of Enabled.
func (s *Currency) SetEnabled(val OptBool) {
        s.Enabled = val
}

// SetDefault sets the value of Default.
func (s *Currency) SetDefault(val OptBool) {
        s.Default = val
}

// SetCode sets the value of Code.
func (s *Currency) SetCode(val string) {
        s.Code = val
}

// SetName sets the value of Name.
func (s *Currency) SetName(val string) {
        s.Name = val
}

// SetSymbol sets the value of Symbol.
func (s *Currency) SetSymbol(val string) {
        s.Symbol = val
}

// SetDecimalPlaces sets the value of DecimalPlaces.
func (s *Currency) SetDecimalPlaces(val OptInt32) {
        s.DecimalPlaces = val
}

// Ref: #/components/schemas/CurrencyArray
type CurrencyArray struct {
        Data  []CurrencyRead `json:"data"`
        Meta  Meta           `json:"meta"`
        Links PageLink       `json:"links"`
}

// GetData returns the value of Data.
func (s *CurrencyArray) GetData() []CurrencyRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *CurrencyArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *CurrencyArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *CurrencyArray) SetData(val []CurrencyRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *CurrencyArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *CurrencyArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*CurrencyArray) listCurrencyRes() {}

// Ref: #/components/schemas/CurrencyRead
type CurrencyRead struct {
        // Immutable value.
        Type       string   `json:"type"`
        ID         string   `json:"id"`
        Attributes Currency `json:"attributes"`
}

// GetType returns the value of Type.
func (s *CurrencyRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *CurrencyRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *CurrencyRead) GetAttributes() Currency {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *CurrencyRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *CurrencyRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *CurrencyRead) SetAttributes(val Currency) {
        s.Attributes = val
}

// Ref: #/components/schemas/CurrencySingle
type CurrencySingle struct {
        Data CurrencyRead `json:"data"`
}

// GetData returns the value of Data.
func (s *CurrencySingle) GetData() CurrencyRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *CurrencySingle) SetData(val CurrencyRead) {
        s.Data = val
}

func (*CurrencySingle) defaultCurrencyRes()    {}
func (*CurrencySingle) disableCurrencyRes()    {}
func (*CurrencySingle) enableCurrencyRes()     {}
func (*CurrencySingle) getCurrencyRes()        {}
func (*CurrencySingle) getDefaultCurrencyRes() {}
func (*CurrencySingle) storeCurrencyRes()      {}
func (*CurrencySingle) updateCurrencyRes()     {}

// Ref: #/components/schemas/CurrencyStore
type CurrencyStore struct {
        // Defaults to true.
        Enabled OptBool `json:"enabled"`
        // Make this currency the default currency.
        Default OptBool `json:"default"`
        Code    string  `json:"code"`
        Name    string  `json:"name"`
        Symbol  string  `json:"symbol"`
        // Supports 0-16 decimals.
        DecimalPlaces OptInt32 `json:"decimal_places"`
}

// GetEnabled returns the value of Enabled.
func (s *CurrencyStore) GetEnabled() OptBool {
        return s.Enabled
}

// GetDefault returns the value of Default.
func (s *CurrencyStore) GetDefault() OptBool {
        return s.Default
}

// GetCode returns the value of Code.
func (s *CurrencyStore) GetCode() string {
        return s.Code
}

// GetName returns the value of Name.
func (s *CurrencyStore) GetName() string {
        return s.Name
}

// GetSymbol returns the value of Symbol.
func (s *CurrencyStore) GetSymbol() string {
        return s.Symbol
}

// GetDecimalPlaces returns the value of DecimalPlaces.
func (s *CurrencyStore) GetDecimalPlaces() OptInt32 {
        return s.DecimalPlaces
}

// SetEnabled sets the value of Enabled.
func (s *CurrencyStore) SetEnabled(val OptBool) {
        s.Enabled = val
}

// SetDefault sets the value of Default.
func (s *CurrencyStore) SetDefault(val OptBool) {
        s.Default = val
}

// SetCode sets the value of Code.
func (s *CurrencyStore) SetCode(val string) {
        s.Code = val
}

// SetName sets the value of Name.
func (s *CurrencyStore) SetName(val string) {
        s.Name = val
}

// SetSymbol sets the value of Symbol.
func (s *CurrencyStore) SetSymbol(val string) {
        s.Symbol = val
}

// SetDecimalPlaces sets the value of DecimalPlaces.
func (s *CurrencyStore) SetDecimalPlaces(val OptInt32) {
        s.DecimalPlaces = val
}

// Ref: #/components/schemas/CurrencyUpdate
type CurrencyUpdate struct {
        // If the currency is enabled.
        Enabled OptBool `json:"enabled"`
        // If the currency must be the default for the user. You can only submit TRUE.
        Default OptCurrencyUpdateDefault `json:"default"`
        // The currency code.
        Code OptString `json:"code"`
        // The currency name.
        Name OptString `json:"name"`
        // The currency symbol.
        Symbol OptString `json:"symbol"`
        // How many decimals to use when displaying this currency. Between 0 and 16.
        DecimalPlaces OptInt32 `json:"decimal_places"`
}

// GetEnabled returns the value of Enabled.
func (s *CurrencyUpdate) GetEnabled() OptBool {
        return s.Enabled
}

// GetDefault returns the value of Default.
func (s *CurrencyUpdate) GetDefault() OptCurrencyUpdateDefault {
        return s.Default
}

// GetCode returns the value of Code.
func (s *CurrencyUpdate) GetCode() OptString {
        return s.Code
}

// GetName returns the value of Name.
func (s *CurrencyUpdate) GetName() OptString {
        return s.Name
}

// GetSymbol returns the value of Symbol.
func (s *CurrencyUpdate) GetSymbol() OptString {
        return s.Symbol
}

// GetDecimalPlaces returns the value of DecimalPlaces.
func (s *CurrencyUpdate) GetDecimalPlaces() OptInt32 {
        return s.DecimalPlaces
}

// SetEnabled sets the value of Enabled.
func (s *CurrencyUpdate) SetEnabled(val OptBool) {
        s.Enabled = val
}

// SetDefault sets the value of Default.
func (s *CurrencyUpdate) SetDefault(val OptCurrencyUpdateDefault) {
        s.Default = val
}

// SetCode sets the value of Code.
func (s *CurrencyUpdate) SetCode(val OptString) {
        s.Code = val
}

// SetName sets the value of Name.
func (s *CurrencyUpdate) SetName(val OptString) {
        s.Name = val
}

// SetSymbol sets the value of Symbol.
func (s *CurrencyUpdate) SetSymbol(val OptString) {
        s.Symbol = val
}

// SetDecimalPlaces sets the value of DecimalPlaces.
func (s *CurrencyUpdate) SetDecimalPlaces(val OptInt32) {
        s.DecimalPlaces = val
}

// If the currency must be the default for the user. You can only submit TRUE.
type CurrencyUpdateDefault bool

const (
        CurrencyUpdateDefaultTrue CurrencyUpdateDefault = true
)

// AllValues returns all CurrencyUpdateDefault values.
func (CurrencyUpdateDefault) AllValues() []CurrencyUpdateDefault {
        return []CurrencyUpdateDefault{
                CurrencyUpdateDefaultTrue,
        }
}

// Ref: #/components/schemas/DataDestroyObject
type DataDestroyObject string

const (
        DataDestroyObjectNotAssetsLiabilities DataDestroyObject = "not_assets_liabilities"
        DataDestroyObjectBudgets              DataDestroyObject = "budgets"
        DataDestroyObjectBills                DataDestroyObject = "bills"
        DataDestroyObjectPiggyBanks           DataDestroyObject = "piggy_banks"
        DataDestroyObjectRules                DataDestroyObject = "rules"
        DataDestroyObjectRecurring            DataDestroyObject = "recurring"
        DataDestroyObjectCategories           DataDestroyObject = "categories"
        DataDestroyObjectTags                 DataDestroyObject = "tags"
        DataDestroyObjectObjectGroups         DataDestroyObject = "object_groups"
        DataDestroyObjectAccounts             DataDestroyObject = "accounts"
        DataDestroyObjectAssetAccounts        DataDestroyObject = "asset_accounts"
        DataDestroyObjectExpenseAccounts      DataDestroyObject = "expense_accounts"
        DataDestroyObjectRevenueAccounts      DataDestroyObject = "revenue_accounts"
        DataDestroyObjectLiabilities          DataDestroyObject = "liabilities"
        DataDestroyObjectTransactions         DataDestroyObject = "transactions"
        DataDestroyObjectWithdrawals          DataDestroyObject = "withdrawals"
        DataDestroyObjectDeposits             DataDestroyObject = "deposits"
        DataDestroyObjectTransfers            DataDestroyObject = "transfers"
)

// AllValues returns all DataDestroyObject values.
func (DataDestroyObject) AllValues() []DataDestroyObject {
        return []DataDestroyObject{
                DataDestroyObjectNotAssetsLiabilities,
                DataDestroyObjectBudgets,
                DataDestroyObjectBills,
                DataDestroyObjectPiggyBanks,
                DataDestroyObjectRules,
                DataDestroyObjectRecurring,
                DataDestroyObjectCategories,
                DataDestroyObjectTags,
                DataDestroyObjectObjectGroups,
                DataDestroyObjectAccounts,
                DataDestroyObjectAssetAccounts,
                DataDestroyObjectExpenseAccounts,
                DataDestroyObjectRevenueAccounts,
                DataDestroyObjectLiabilities,
                DataDestroyObjectTransactions,
                DataDestroyObjectWithdrawals,
                DataDestroyObjectDeposits,
                DataDestroyObjectTransfers,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s DataDestroyObject) MarshalText() ([]byte, error) {
        switch s {
        case DataDestroyObjectNotAssetsLiabilities:
                return []byte(s), nil
        case DataDestroyObjectBudgets:
                return []byte(s), nil
        case DataDestroyObjectBills:
                return []byte(s), nil
        case DataDestroyObjectPiggyBanks:
                return []byte(s), nil
        case DataDestroyObjectRules:
                return []byte(s), nil
        case DataDestroyObjectRecurring:
                return []byte(s), nil
        case DataDestroyObjectCategories:
                return []byte(s), nil
        case DataDestroyObjectTags:
                return []byte(s), nil
        case DataDestroyObjectObjectGroups:
                return []byte(s), nil
        case DataDestroyObjectAccounts:
                return []byte(s), nil
        case DataDestroyObjectAssetAccounts:
                return []byte(s), nil
        case DataDestroyObjectExpenseAccounts:
                return []byte(s), nil
        case DataDestroyObjectRevenueAccounts:
                return []byte(s), nil
        case DataDestroyObjectLiabilities:
                return []byte(s), nil
        case DataDestroyObjectTransactions:
                return []byte(s), nil
        case DataDestroyObjectWithdrawals:
                return []byte(s), nil
        case DataDestroyObjectDeposits:
                return []byte(s), nil
        case DataDestroyObjectTransfers:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *DataDestroyObject) UnmarshalText(data []byte) error {
        switch DataDestroyObject(data) {
        case DataDestroyObjectNotAssetsLiabilities:
                *s = DataDestroyObjectNotAssetsLiabilities
                return nil
        case DataDestroyObjectBudgets:
                *s = DataDestroyObjectBudgets
                return nil
        case DataDestroyObjectBills:
                *s = DataDestroyObjectBills
                return nil
        case DataDestroyObjectPiggyBanks:
                *s = DataDestroyObjectPiggyBanks
                return nil
        case DataDestroyObjectRules:
                *s = DataDestroyObjectRules
                return nil
        case DataDestroyObjectRecurring:
                *s = DataDestroyObjectRecurring
                return nil
        case DataDestroyObjectCategories:
                *s = DataDestroyObjectCategories
                return nil
        case DataDestroyObjectTags:
                *s = DataDestroyObjectTags
                return nil
        case DataDestroyObjectObjectGroups:
                *s = DataDestroyObjectObjectGroups
                return nil
        case DataDestroyObjectAccounts:
                *s = DataDestroyObjectAccounts
                return nil
        case DataDestroyObjectAssetAccounts:
                *s = DataDestroyObjectAssetAccounts
                return nil
        case DataDestroyObjectExpenseAccounts:
                *s = DataDestroyObjectExpenseAccounts
                return nil
        case DataDestroyObjectRevenueAccounts:
                *s = DataDestroyObjectRevenueAccounts
                return nil
        case DataDestroyObjectLiabilities:
                *s = DataDestroyObjectLiabilities
                return nil
        case DataDestroyObjectTransactions:
                *s = DataDestroyObjectTransactions
                return nil
        case DataDestroyObjectWithdrawals:
                *s = DataDestroyObjectWithdrawals
                return nil
        case DataDestroyObjectDeposits:
                *s = DataDestroyObjectDeposits
                return nil
        case DataDestroyObjectTransfers:
                *s = DataDestroyObjectTransfers
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// DeleteAccountNoContent is response for DeleteAccount operation.
type DeleteAccountNoContent struct{}

func (*DeleteAccountNoContent) deleteAccountRes() {}

// DeleteAttachmentNoContent is response for DeleteAttachment operation.
type DeleteAttachmentNoContent struct{}

func (*DeleteAttachmentNoContent) deleteAttachmentRes() {}

// DeleteBillNoContent is response for DeleteBill operation.
type DeleteBillNoContent struct{}

func (*DeleteBillNoContent) deleteBillRes() {}

// DeleteBudgetLimitNoContent is response for DeleteBudgetLimit operation.
type DeleteBudgetLimitNoContent struct{}

func (*DeleteBudgetLimitNoContent) deleteBudgetLimitRes() {}

// DeleteBudgetNoContent is response for DeleteBudget operation.
type DeleteBudgetNoContent struct{}

func (*DeleteBudgetNoContent) deleteBudgetRes() {}

// DeleteCategoryNoContent is response for DeleteCategory operation.
type DeleteCategoryNoContent struct{}

func (*DeleteCategoryNoContent) deleteCategoryRes() {}

// DeleteCurrencyNoContent is response for DeleteCurrency operation.
type DeleteCurrencyNoContent struct{}

func (*DeleteCurrencyNoContent) deleteCurrencyRes() {}

// DeleteLinkTypeNoContent is response for DeleteLinkType operation.
type DeleteLinkTypeNoContent struct{}

func (*DeleteLinkTypeNoContent) deleteLinkTypeRes() {}

// DeleteObjectGroupNoContent is response for DeleteObjectGroup operation.
type DeleteObjectGroupNoContent struct{}

func (*DeleteObjectGroupNoContent) deleteObjectGroupRes() {}

// DeletePiggyBankNoContent is response for DeletePiggyBank operation.
type DeletePiggyBankNoContent struct{}

func (*DeletePiggyBankNoContent) deletePiggyBankRes() {}

// DeleteRecurrenceNoContent is response for DeleteRecurrence operation.
type DeleteRecurrenceNoContent struct{}

func (*DeleteRecurrenceNoContent) deleteRecurrenceRes() {}

// DeleteRuleGroupNoContent is response for DeleteRuleGroup operation.
type DeleteRuleGroupNoContent struct{}

func (*DeleteRuleGroupNoContent) deleteRuleGroupRes() {}

// DeleteRuleNoContent is response for DeleteRule operation.
type DeleteRuleNoContent struct{}

func (*DeleteRuleNoContent) deleteRuleRes() {}

// DeleteTagNoContent is response for DeleteTag operation.
type DeleteTagNoContent struct{}

func (*DeleteTagNoContent) deleteTagRes() {}

// DeleteTransactionJournalNoContent is response for DeleteTransactionJournal operation.
type DeleteTransactionJournalNoContent struct{}

func (*DeleteTransactionJournalNoContent) deleteTransactionJournalRes() {}

// DeleteTransactionLinkNoContent is response for DeleteTransactionLink operation.
type DeleteTransactionLinkNoContent struct{}

func (*DeleteTransactionLinkNoContent) deleteTransactionLinkRes() {}

// DeleteTransactionNoContent is response for DeleteTransaction operation.
type DeleteTransactionNoContent struct{}

func (*DeleteTransactionNoContent) deleteTransactionRes() {}

// DeleteUserNoContent is response for DeleteUser operation.
type DeleteUserNoContent struct{}

func (*DeleteUserNoContent) deleteUserRes() {}

// DeleteWebhookMessageAttemptNoContent is response for DeleteWebhookMessageAttempt operation.
type DeleteWebhookMessageAttemptNoContent struct{}

func (*DeleteWebhookMessageAttemptNoContent) deleteWebhookMessageAttemptRes() {}

// DeleteWebhookMessageNoContent is response for DeleteWebhookMessage operation.
type DeleteWebhookMessageNoContent struct{}

func (*DeleteWebhookMessageNoContent) deleteWebhookMessageRes() {}

// DeleteWebhookNoContent is response for DeleteWebhook operation.
type DeleteWebhookNoContent struct{}

func (*DeleteWebhookNoContent) deleteWebhookRes() {}

// DestroyDataNoContent is response for DestroyData operation.
type DestroyDataNoContent struct{}

func (*DestroyDataNoContent) destroyDataRes() {}

// DisableCurrencyConflict is response for DisableCurrency operation.
type DisableCurrencyConflict struct{}

func (*DisableCurrencyConflict) disableCurrencyRes() {}

type DownloadAttachmentOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s DownloadAttachmentOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*DownloadAttachmentOK) downloadAttachmentRes() {}

type ExportAccountsOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportAccountsOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportAccountsOK) exportAccountsRes() {}

type ExportBillsOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportBillsOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportBillsOK) exportBillsRes() {}

type ExportBudgetsOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportBudgetsOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportBudgetsOK) exportBudgetsRes() {}

type ExportCategoriesOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportCategoriesOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportCategoriesOK) exportCategoriesRes() {}

// Ref: #/components/schemas/ExportFileFilter
type ExportFileFilter string

const (
        ExportFileFilterCsv ExportFileFilter = "csv"
)

// AllValues returns all ExportFileFilter values.
func (ExportFileFilter) AllValues() []ExportFileFilter {
        return []ExportFileFilter{
                ExportFileFilterCsv,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s ExportFileFilter) MarshalText() ([]byte, error) {
        switch s {
        case ExportFileFilterCsv:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *ExportFileFilter) UnmarshalText(data []byte) error {
        switch ExportFileFilter(data) {
        case ExportFileFilterCsv:
                *s = ExportFileFilterCsv
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

type ExportPiggiesOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportPiggiesOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportPiggiesOK) exportPiggiesRes() {}

type ExportRecurringOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportRecurringOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportRecurringOK) exportRecurringRes() {}

type ExportRulesOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportRulesOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportRulesOK) exportRulesRes() {}

type ExportTagsOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportTagsOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportTagsOK) exportTagsRes() {}

type ExportTransactionsOK struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s ExportTransactionsOK) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

func (*ExportTransactionsOK) exportTransactionsRes() {}

// FireRuleGroupNoContent is response for FireRuleGroup operation.
type FireRuleGroupNoContent struct{}

func (*FireRuleGroupNoContent) fireRuleGroupRes() {}

// FireRuleNoContent is response for FireRule operation.
type FireRuleNoContent struct{}

func (*FireRuleNoContent) fireRuleRes() {}

type FireflyIiiAuth struct {
        Token  string
        Scopes []string
}

// GetToken returns the value of Token.
func (s *FireflyIiiAuth) GetToken() string {
        return s.Token
}

// GetScopes returns the value of Scopes.
func (s *FireflyIiiAuth) GetScopes() []string {
        return s.Scopes
}

// SetToken sets the value of Token.
func (s *FireflyIiiAuth) SetToken(val string) {
        s.Token = val
}

// SetScopes sets the value of Scopes.
func (s *FireflyIiiAuth) SetScopes(val []string) {
        s.Scopes = val
}

type InsightGroup []InsightGroupEntry

func (*InsightGroup) insightExpenseAssetRes()     {}
func (*InsightGroup) insightExpenseBillRes()      {}
func (*InsightGroup) insightExpenseBudgetRes()    {}
func (*InsightGroup) insightExpenseCategoryRes()  {}
func (*InsightGroup) insightExpenseExpenseRes()   {}
func (*InsightGroup) insightExpenseTagRes()       {}
func (*InsightGroup) insightIncomeAssetRes()      {}
func (*InsightGroup) insightIncomeCategoryRes()   {}
func (*InsightGroup) insightIncomeRevenueRes()    {}
func (*InsightGroup) insightIncomeTagRes()        {}
func (*InsightGroup) insightTransferCategoryRes() {}
func (*InsightGroup) insightTransferTagRes()      {}

// Ref: #/components/schemas/InsightGroupEntry
type InsightGroupEntry struct {
        // This ID is a reference to the original object.
        ID OptString `json:"id"`
        // This is the name of the object.
        Name OptString `json:"name"`
        // The amount spent or earned between start date and end date, a number defined as a string, for this
        // object and all asset accounts.
        Difference OptString `json:"difference"`
        // The amount spent or earned between start date and end date, a number as a float, for this object
        // and all asset accounts. May have rounding errors.
        DifferenceFloat OptFloat64 `json:"difference_float"`
        // The currency ID of the expenses listed for this account.
        CurrencyID OptString `json:"currency_id"`
        // The currency code of the expenses listed for this account.
        CurrencyCode OptString `json:"currency_code"`
}

// GetID returns the value of ID.
func (s *InsightGroupEntry) GetID() OptString {
        return s.ID
}

// GetName returns the value of Name.
func (s *InsightGroupEntry) GetName() OptString {
        return s.Name
}

// GetDifference returns the value of Difference.
func (s *InsightGroupEntry) GetDifference() OptString {
        return s.Difference
}

// GetDifferenceFloat returns the value of DifferenceFloat.
func (s *InsightGroupEntry) GetDifferenceFloat() OptFloat64 {
        return s.DifferenceFloat
}

// GetCurrencyID returns the value of CurrencyID.
func (s *InsightGroupEntry) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *InsightGroupEntry) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// SetID sets the value of ID.
func (s *InsightGroupEntry) SetID(val OptString) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *InsightGroupEntry) SetName(val OptString) {
        s.Name = val
}

// SetDifference sets the value of Difference.
func (s *InsightGroupEntry) SetDifference(val OptString) {
        s.Difference = val
}

// SetDifferenceFloat sets the value of DifferenceFloat.
func (s *InsightGroupEntry) SetDifferenceFloat(val OptFloat64) {
        s.DifferenceFloat = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *InsightGroupEntry) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *InsightGroupEntry) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

type InsightTotal []InsightTotalEntry

func (*InsightTotal) insightExpenseNoBillRes()      {}
func (*InsightTotal) insightExpenseNoBudgetRes()    {}
func (*InsightTotal) insightExpenseNoCategoryRes()  {}
func (*InsightTotal) insightExpenseNoTagRes()       {}
func (*InsightTotal) insightExpenseTotalRes()       {}
func (*InsightTotal) insightIncomeNoCategoryRes()   {}
func (*InsightTotal) insightIncomeNoTagRes()        {}
func (*InsightTotal) insightIncomeTotalRes()        {}
func (*InsightTotal) insightTransferNoCategoryRes() {}
func (*InsightTotal) insightTransferNoTagRes()      {}
func (*InsightTotal) insightTransferTotalRes()      {}

// Ref: #/components/schemas/InsightTotalEntry
type InsightTotalEntry struct {
        // The amount spent between start date and end date, defined as a string, for this expense account
        // and all asset accounts.
        Difference OptString `json:"difference"`
        // The amount spent between start date and end date, defined as a string, for this expense account
        // and all asset accounts. This number is a float (double) and may have rounding errors.
        DifferenceFloat OptFloat64 `json:"difference_float"`
        // The currency ID of the expenses listed for this expense account.
        CurrencyID OptString `json:"currency_id"`
        // The currency code of the expenses listed for this expense account.
        CurrencyCode OptString `json:"currency_code"`
}

// GetDifference returns the value of Difference.
func (s *InsightTotalEntry) GetDifference() OptString {
        return s.Difference
}

// GetDifferenceFloat returns the value of DifferenceFloat.
func (s *InsightTotalEntry) GetDifferenceFloat() OptFloat64 {
        return s.DifferenceFloat
}

// GetCurrencyID returns the value of CurrencyID.
func (s *InsightTotalEntry) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *InsightTotalEntry) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// SetDifference sets the value of Difference.
func (s *InsightTotalEntry) SetDifference(val OptString) {
        s.Difference = val
}

// SetDifferenceFloat sets the value of DifferenceFloat.
func (s *InsightTotalEntry) SetDifferenceFloat(val OptFloat64) {
        s.DifferenceFloat = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *InsightTotalEntry) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *InsightTotalEntry) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

type InsightTransfer []InsightTransferEntry

func (*InsightTransfer) insightTransfersRes() {}

// Ref: #/components/schemas/InsightTransferEntry
type InsightTransferEntry struct {
        // This ID is a reference to the original object.
        ID OptString `json:"id"`
        // This is the name of the object.
        Name OptString `json:"name"`
        // The total amount transferred between start date and end date, a number defined as a string, for
        // this asset account.
        Difference OptString `json:"difference"`
        // The total amount transferred between start date and end date, a number as a float, for this asset
        // account. May have rounding errors.
        DifferenceFloat OptFloat64 `json:"difference_float"`
        // The total amount transferred TO this account between start date and end date, a number defined as
        // a string, for this asset account.
        In OptString `json:"in"`
        // The total amount transferred FROM this account between start date and end date, a number as a
        // float, for this asset account. May have rounding errors.
        InFloat OptFloat64 `json:"in_float"`
        // The total amount transferred FROM this account between start date and end date, a number defined
        // as a string, for this asset account.
        Out OptString `json:"out"`
        // The total amount transferred TO this account between start date and end date, a number as a float,
        // for this asset account. May have rounding errors.
        OutFloat OptFloat64 `json:"out_float"`
        // The currency ID of the expenses listed for this account.
        CurrencyID OptString `json:"currency_id"`
        // The currency code of the expenses listed for this account.
        CurrencyCode OptString `json:"currency_code"`
}

// GetID returns the value of ID.
func (s *InsightTransferEntry) GetID() OptString {
        return s.ID
}

// GetName returns the value of Name.
func (s *InsightTransferEntry) GetName() OptString {
        return s.Name
}

// GetDifference returns the value of Difference.
func (s *InsightTransferEntry) GetDifference() OptString {
        return s.Difference
}

// GetDifferenceFloat returns the value of DifferenceFloat.
func (s *InsightTransferEntry) GetDifferenceFloat() OptFloat64 {
        return s.DifferenceFloat
}

// GetIn returns the value of In.
func (s *InsightTransferEntry) GetIn() OptString {
        return s.In
}

// GetInFloat returns the value of InFloat.
func (s *InsightTransferEntry) GetInFloat() OptFloat64 {
        return s.InFloat
}

// GetOut returns the value of Out.
func (s *InsightTransferEntry) GetOut() OptString {
        return s.Out
}

// GetOutFloat returns the value of OutFloat.
func (s *InsightTransferEntry) GetOutFloat() OptFloat64 {
        return s.OutFloat
}

// GetCurrencyID returns the value of CurrencyID.
func (s *InsightTransferEntry) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *InsightTransferEntry) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// SetID sets the value of ID.
func (s *InsightTransferEntry) SetID(val OptString) {
        s.ID = val
}

// SetName sets the value of Name.
func (s *InsightTransferEntry) SetName(val OptString) {
        s.Name = val
}

// SetDifference sets the value of Difference.
func (s *InsightTransferEntry) SetDifference(val OptString) {
        s.Difference = val
}

// SetDifferenceFloat sets the value of DifferenceFloat.
func (s *InsightTransferEntry) SetDifferenceFloat(val OptFloat64) {
        s.DifferenceFloat = val
}

// SetIn sets the value of In.
func (s *InsightTransferEntry) SetIn(val OptString) {
        s.In = val
}

// SetInFloat sets the value of InFloat.
func (s *InsightTransferEntry) SetInFloat(val OptFloat64) {
        s.InFloat = val
}

// SetOut sets the value of Out.
func (s *InsightTransferEntry) SetOut(val OptString) {
        s.Out = val
}

// SetOutFloat sets the value of OutFloat.
func (s *InsightTransferEntry) SetOutFloat(val OptFloat64) {
        s.OutFloat = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *InsightTransferEntry) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *InsightTransferEntry) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// Mandatory when type is liability. Period over which the interest is calculated.
// Ref: #/components/schemas/InterestPeriod
type InterestPeriod string

const (
        InterestPeriodWeekly    InterestPeriod = "weekly"
        InterestPeriodMonthly   InterestPeriod = "monthly"
        InterestPeriodQuarterly InterestPeriod = "quarterly"
        InterestPeriodHalfYear  InterestPeriod = "half-year"
        InterestPeriodYearly    InterestPeriod = "yearly"
)

// AllValues returns all InterestPeriod values.
func (InterestPeriod) AllValues() []InterestPeriod {
        return []InterestPeriod{
                InterestPeriodWeekly,
                InterestPeriodMonthly,
                InterestPeriodQuarterly,
                InterestPeriodHalfYear,
                InterestPeriodYearly,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s InterestPeriod) MarshalText() ([]byte, error) {
        switch s {
        case InterestPeriodWeekly:
                return []byte(s), nil
        case InterestPeriodMonthly:
                return []byte(s), nil
        case InterestPeriodQuarterly:
                return []byte(s), nil
        case InterestPeriodHalfYear:
                return []byte(s), nil
        case InterestPeriodYearly:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *InterestPeriod) UnmarshalText(data []byte) error {
        switch InterestPeriod(data) {
        case InterestPeriodWeekly:
                *s = InterestPeriodWeekly
                return nil
        case InterestPeriodMonthly:
                *s = InterestPeriodMonthly
                return nil
        case InterestPeriodQuarterly:
                *s = InterestPeriodQuarterly
                return nil
        case InterestPeriodHalfYear:
                *s = InterestPeriodHalfYear
                return nil
        case InterestPeriodYearly:
                *s = InterestPeriodYearly
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/InternalException
type InternalException struct {
        Message   OptString `json:"message"`
        Exception OptString `json:"exception"`
}

// GetMessage returns the value of Message.
func (s *InternalException) GetMessage() OptString {
        return s.Message
}

// GetException returns the value of Exception.
func (s *InternalException) GetException() OptString {
        return s.Exception
}

// SetMessage sets the value of Message.
func (s *InternalException) SetMessage(val OptString) {
        s.Message = val
}

// SetException sets the value of Exception.
func (s *InternalException) SetException(val OptString) {
        s.Exception = val
}

func (*InternalException) bulkUpdateTransactionsRes()         {}
func (*InternalException) defaultCurrencyRes()                {}
func (*InternalException) deleteAccountRes()                  {}
func (*InternalException) deleteAttachmentRes()               {}
func (*InternalException) deleteBillRes()                     {}
func (*InternalException) deleteBudgetLimitRes()              {}
func (*InternalException) deleteBudgetRes()                   {}
func (*InternalException) deleteCategoryRes()                 {}
func (*InternalException) deleteCurrencyRes()                 {}
func (*InternalException) deleteLinkTypeRes()                 {}
func (*InternalException) deleteObjectGroupRes()              {}
func (*InternalException) deletePiggyBankRes()                {}
func (*InternalException) deleteRecurrenceRes()               {}
func (*InternalException) deleteRuleGroupRes()                {}
func (*InternalException) deleteRuleRes()                     {}
func (*InternalException) deleteTagRes()                      {}
func (*InternalException) deleteTransactionJournalRes()       {}
func (*InternalException) deleteTransactionLinkRes()          {}
func (*InternalException) deleteTransactionRes()              {}
func (*InternalException) deleteUserRes()                     {}
func (*InternalException) deleteWebhookMessageAttemptRes()    {}
func (*InternalException) deleteWebhookMessageRes()           {}
func (*InternalException) deleteWebhookRes()                  {}
func (*InternalException) destroyDataRes()                    {}
func (*InternalException) disableCurrencyRes()                {}
func (*InternalException) downloadAttachmentRes()             {}
func (*InternalException) enableCurrencyRes()                 {}
func (*InternalException) exportAccountsRes()                 {}
func (*InternalException) exportBillsRes()                    {}
func (*InternalException) exportBudgetsRes()                  {}
func (*InternalException) exportCategoriesRes()               {}
func (*InternalException) exportPiggiesRes()                  {}
func (*InternalException) exportRecurringRes()                {}
func (*InternalException) exportRulesRes()                    {}
func (*InternalException) exportTagsRes()                     {}
func (*InternalException) exportTransactionsRes()             {}
func (*InternalException) fireRuleGroupRes()                  {}
func (*InternalException) fireRuleRes()                       {}
func (*InternalException) getAboutRes()                       {}
func (*InternalException) getAccountRes()                     {}
func (*InternalException) getAccountsACRes()                  {}
func (*InternalException) getAttachmentRes()                  {}
func (*InternalException) getAvailableBudgetRes()             {}
func (*InternalException) getBasicSummaryRes()                {}
func (*InternalException) getBillRes()                        {}
func (*InternalException) getBillsACRes()                     {}
func (*InternalException) getBudgetLimitRes()                 {}
func (*InternalException) getBudgetRes()                      {}
func (*InternalException) getBudgetsACRes()                   {}
func (*InternalException) getCategoriesACRes()                {}
func (*InternalException) getCategoryRes()                    {}
func (*InternalException) getChartAccountOverviewRes()        {}
func (*InternalException) getConfigurationRes()               {}
func (*InternalException) getCronRes()                        {}
func (*InternalException) getCurrenciesACRes()                {}
func (*InternalException) getCurrenciesCodeACRes()            {}
func (*InternalException) getCurrencyRes()                    {}
func (*InternalException) getCurrentUserRes()                 {}
func (*InternalException) getDefaultCurrencyRes()             {}
func (*InternalException) getLinkTypeRes()                    {}
func (*InternalException) getObjectGroupRes()                 {}
func (*InternalException) getObjectGroupsACRes()              {}
func (*InternalException) getPiggiesACRes()                   {}
func (*InternalException) getPiggiesBalanceACRes()            {}
func (*InternalException) getPiggyBankRes()                   {}
func (*InternalException) getPreferenceRes()                  {}
func (*InternalException) getRecurrenceRes()                  {}
func (*InternalException) getRecurringACRes()                 {}
func (*InternalException) getRuleGroupRes()                   {}
func (*InternalException) getRuleGroupsACRes()                {}
func (*InternalException) getRuleRes()                        {}
func (*InternalException) getRulesACRes()                     {}
func (*InternalException) getSingleConfigurationRes()         {}
func (*InternalException) getSingleWebhookMessageAttemptRes() {}
func (*InternalException) getSingleWebhookMessageRes()        {}
func (*InternalException) getTagACRes()                       {}
func (*InternalException) getTagRes()                         {}
func (*InternalException) getTransactionByJournalRes()        {}
func (*InternalException) getTransactionLinkRes()             {}
func (*InternalException) getTransactionRes()                 {}
func (*InternalException) getTransactionTypesACRes()          {}
func (*InternalException) getTransactionsACRes()              {}
func (*InternalException) getTransactionsIDACRes()            {}
func (*InternalException) getUserRes()                        {}
func (*InternalException) getWebhookMessageAttemptsRes()      {}
func (*InternalException) getWebhookMessagesRes()             {}
func (*InternalException) getWebhookRes()                     {}
func (*InternalException) insightExpenseAssetRes()            {}
func (*InternalException) insightExpenseBillRes()             {}
func (*InternalException) insightExpenseBudgetRes()           {}
func (*InternalException) insightExpenseCategoryRes()         {}
func (*InternalException) insightExpenseExpenseRes()          {}
func (*InternalException) insightExpenseNoBillRes()           {}
func (*InternalException) insightExpenseNoBudgetRes()         {}
func (*InternalException) insightExpenseNoCategoryRes()       {}
func (*InternalException) insightExpenseNoTagRes()            {}
func (*InternalException) insightExpenseTagRes()              {}
func (*InternalException) insightExpenseTotalRes()            {}
func (*InternalException) insightIncomeAssetRes()             {}
func (*InternalException) insightIncomeCategoryRes()          {}
func (*InternalException) insightIncomeNoCategoryRes()        {}
func (*InternalException) insightIncomeNoTagRes()             {}
func (*InternalException) insightIncomeRevenueRes()           {}
func (*InternalException) insightIncomeTagRes()               {}
func (*InternalException) insightIncomeTotalRes()             {}
func (*InternalException) insightTransferCategoryRes()        {}
func (*InternalException) insightTransferNoCategoryRes()      {}
func (*InternalException) insightTransferNoTagRes()           {}
func (*InternalException) insightTransferTagRes()             {}
func (*InternalException) insightTransferTotalRes()           {}
func (*InternalException) insightTransfersRes()               {}
func (*InternalException) listAccountByCurrencyRes()          {}
func (*InternalException) listAccountRes()                    {}
func (*InternalException) listAttachmentByAccountRes()        {}
func (*InternalException) listAttachmentByBillRes()           {}
func (*InternalException) listAttachmentByBudgetRes()         {}
func (*InternalException) listAttachmentByCategoryRes()       {}
func (*InternalException) listAttachmentByPiggyBankRes()      {}
func (*InternalException) listAttachmentByTagRes()            {}
func (*InternalException) listAttachmentByTransactionRes()    {}
func (*InternalException) listAttachmentRes()                 {}
func (*InternalException) listAvailableBudgetByCurrencyRes()  {}
func (*InternalException) listAvailableBudgetRes()            {}
func (*InternalException) listBillByCurrencyRes()             {}
func (*InternalException) listBillByObjectGroupRes()          {}
func (*InternalException) listBillRes()                       {}
func (*InternalException) listBudgetLimitByBudgetRes()        {}
func (*InternalException) listBudgetLimitByCurrencyRes()      {}
func (*InternalException) listBudgetLimitRes()                {}
func (*InternalException) listBudgetRes()                     {}
func (*InternalException) listCategoryRes()                   {}
func (*InternalException) listCurrencyRes()                   {}
func (*InternalException) listEventByPiggyBankRes()           {}
func (*InternalException) listEventByTransactionRes()         {}
func (*InternalException) listLinkTypeRes()                   {}
func (*InternalException) listLinksByJournalRes()             {}
func (*InternalException) listObjectGroupsRes()               {}
func (*InternalException) listPiggyBankByAccountRes()         {}
func (*InternalException) listPiggyBankByObjectGroupRes()     {}
func (*InternalException) listPiggyBankRes()                  {}
func (*InternalException) listPreferenceRes()                 {}
func (*InternalException) listRecurrenceByCurrencyRes()       {}
func (*InternalException) listRecurrenceRes()                 {}
func (*InternalException) listRuleByBillRes()                 {}
func (*InternalException) listRuleByCurrencyRes()             {}
func (*InternalException) listRuleByGroupRes()                {}
func (*InternalException) listRuleGroupRes()                  {}
func (*InternalException) listRuleRes()                       {}
func (*InternalException) listTagRes()                        {}
func (*InternalException) listTransactionByAccountRes()       {}
func (*InternalException) listTransactionByBillRes()          {}
func (*InternalException) listTransactionByBudgetLimitRes()   {}
func (*InternalException) listTransactionByBudgetRes()        {}
func (*InternalException) listTransactionByCategoryRes()      {}
func (*InternalException) listTransactionByCurrencyRes()      {}
func (*InternalException) listTransactionByLinkTypeRes()      {}
func (*InternalException) listTransactionByRecurrenceRes()    {}
func (*InternalException) listTransactionByTagRes()           {}
func (*InternalException) listTransactionLinkRes()            {}
func (*InternalException) listTransactionRes()                {}
func (*InternalException) listUserRes()                       {}
func (*InternalException) listWebhookRes()                    {}
func (*InternalException) purgeDataRes()                      {}
func (*InternalException) searchAccountsRes()                 {}
func (*InternalException) searchTransactionsRes()             {}
func (*InternalException) setConfigurationRes()               {}
func (*InternalException) storeAccountRes()                   {}
func (*InternalException) storeAttachmentRes()                {}
func (*InternalException) storeBillRes()                      {}
func (*InternalException) storeBudgetLimitRes()               {}
func (*InternalException) storeBudgetRes()                    {}
func (*InternalException) storeCategoryRes()                  {}
func (*InternalException) storeCurrencyRes()                  {}
func (*InternalException) storeLinkTypeRes()                  {}
func (*InternalException) storePiggyBankRes()                 {}
func (*InternalException) storePreferenceRes()                {}
func (*InternalException) storeRecurrenceRes()                {}
func (*InternalException) storeRuleGroupRes()                 {}
func (*InternalException) storeRuleRes()                      {}
func (*InternalException) storeTagRes()                       {}
func (*InternalException) storeTransactionLinkRes()           {}
func (*InternalException) storeTransactionRes()               {}
func (*InternalException) storeUserRes()                      {}
func (*InternalException) storeWebhookRes()                   {}
func (*InternalException) testRuleGroupRes()                  {}
func (*InternalException) testRuleRes()                       {}
func (*InternalException) updateAccountRes()                  {}
func (*InternalException) updateAttachmentRes()               {}
func (*InternalException) updateBillRes()                     {}
func (*InternalException) updateBudgetLimitRes()              {}
func (*InternalException) updateBudgetRes()                   {}
func (*InternalException) updateCategoryRes()                 {}
func (*InternalException) updateCurrencyRes()                 {}
func (*InternalException) updateLinkTypeRes()                 {}
func (*InternalException) updateObjectGroupRes()              {}
func (*InternalException) updatePiggyBankRes()                {}
func (*InternalException) updatePreferenceRes()               {}
func (*InternalException) updateRecurrenceRes()               {}
func (*InternalException) updateRuleGroupRes()                {}
func (*InternalException) updateRuleRes()                     {}
func (*InternalException) updateTagRes()                      {}
func (*InternalException) updateTransactionLinkRes()          {}
func (*InternalException) updateTransactionRes()              {}
func (*InternalException) updateUserRes()                     {}
func (*InternalException) updateWebhookRes()                  {}
func (*InternalException) uploadAttachmentRes()               {}

// 'credit' indicates somebody owes you the liability. 'debit' Indicates you owe this debt yourself.
// Works only for liabiltiies.
// Ref: #/components/schemas/LiabilityDirection
type LiabilityDirection string

const (
        LiabilityDirectionCredit LiabilityDirection = "credit"
        LiabilityDirectionDebit  LiabilityDirection = "debit"
)

// AllValues returns all LiabilityDirection values.
func (LiabilityDirection) AllValues() []LiabilityDirection {
        return []LiabilityDirection{
                LiabilityDirectionCredit,
                LiabilityDirectionDebit,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s LiabilityDirection) MarshalText() ([]byte, error) {
        switch s {
        case LiabilityDirectionCredit:
                return []byte(s), nil
        case LiabilityDirectionDebit:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *LiabilityDirection) UnmarshalText(data []byte) error {
        switch LiabilityDirection(data) {
        case LiabilityDirectionCredit:
                *s = LiabilityDirectionCredit
                return nil
        case LiabilityDirectionDebit:
                *s = LiabilityDirectionDebit
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Mandatory when type is liability. Specifies the exact type.
// Ref: #/components/schemas/LiabilityType
type LiabilityType string

const (
        LiabilityTypeLoan     LiabilityType = "loan"
        LiabilityTypeDebt     LiabilityType = "debt"
        LiabilityTypeMortgage LiabilityType = "mortgage"
)

// AllValues returns all LiabilityType values.
func (LiabilityType) AllValues() []LiabilityType {
        return []LiabilityType{
                LiabilityTypeLoan,
                LiabilityTypeDebt,
                LiabilityTypeMortgage,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s LiabilityType) MarshalText() ([]byte, error) {
        switch s {
        case LiabilityTypeLoan:
                return []byte(s), nil
        case LiabilityTypeDebt:
                return []byte(s), nil
        case LiabilityTypeMortgage:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *LiabilityType) UnmarshalText(data []byte) error {
        switch LiabilityType(data) {
        case LiabilityTypeLoan:
                *s = LiabilityTypeLoan
                return nil
        case LiabilityTypeDebt:
                *s = LiabilityTypeDebt
                return nil
        case LiabilityTypeMortgage:
                *s = LiabilityTypeMortgage
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/LinkType
type LinkType struct {
        Name     string  `json:"name"`
        Inward   string  `json:"inward"`
        Outward  string  `json:"outward"`
        Editable OptBool `json:"editable"`
}

// GetName returns the value of Name.
func (s *LinkType) GetName() string {
        return s.Name
}

// GetInward returns the value of Inward.
func (s *LinkType) GetInward() string {
        return s.Inward
}

// GetOutward returns the value of Outward.
func (s *LinkType) GetOutward() string {
        return s.Outward
}

// GetEditable returns the value of Editable.
func (s *LinkType) GetEditable() OptBool {
        return s.Editable
}

// SetName sets the value of Name.
func (s *LinkType) SetName(val string) {
        s.Name = val
}

// SetInward sets the value of Inward.
func (s *LinkType) SetInward(val string) {
        s.Inward = val
}

// SetOutward sets the value of Outward.
func (s *LinkType) SetOutward(val string) {
        s.Outward = val
}

// SetEditable sets the value of Editable.
func (s *LinkType) SetEditable(val OptBool) {
        s.Editable = val
}

// Ref: #/components/schemas/LinkTypeArray
type LinkTypeArray struct {
        Data  []LinkTypeRead `json:"data"`
        Meta  Meta           `json:"meta"`
        Links PageLink       `json:"links"`
}

// GetData returns the value of Data.
func (s *LinkTypeArray) GetData() []LinkTypeRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *LinkTypeArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *LinkTypeArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *LinkTypeArray) SetData(val []LinkTypeRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *LinkTypeArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *LinkTypeArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*LinkTypeArray) listLinkTypeRes() {}

// Ref: #/components/schemas/LinkTypeRead
type LinkTypeRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes LinkType   `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *LinkTypeRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *LinkTypeRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *LinkTypeRead) GetAttributes() LinkType {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *LinkTypeRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *LinkTypeRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *LinkTypeRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *LinkTypeRead) SetAttributes(val LinkType) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *LinkTypeRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/LinkTypeSingle
type LinkTypeSingle struct {
        Data LinkTypeRead `json:"data"`
}

// GetData returns the value of Data.
func (s *LinkTypeSingle) GetData() LinkTypeRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *LinkTypeSingle) SetData(val LinkTypeRead) {
        s.Data = val
}

func (*LinkTypeSingle) getLinkTypeRes()    {}
func (*LinkTypeSingle) storeLinkTypeRes()  {}
func (*LinkTypeSingle) updateLinkTypeRes() {}

// Ref: #/components/schemas/LinkTypeUpdate
type LinkTypeUpdate struct {
        Name    OptString `json:"name"`
        Inward  OptString `json:"inward"`
        Outward OptString `json:"outward"`
}

// GetName returns the value of Name.
func (s *LinkTypeUpdate) GetName() OptString {
        return s.Name
}

// GetInward returns the value of Inward.
func (s *LinkTypeUpdate) GetInward() OptString {
        return s.Inward
}

// GetOutward returns the value of Outward.
func (s *LinkTypeUpdate) GetOutward() OptString {
        return s.Outward
}

// SetName sets the value of Name.
func (s *LinkTypeUpdate) SetName(val OptString) {
        s.Name = val
}

// SetInward sets the value of Inward.
func (s *LinkTypeUpdate) SetInward(val OptString) {
        s.Inward = val
}

// SetOutward sets the value of Outward.
func (s *LinkTypeUpdate) SetOutward(val OptString) {
        s.Outward = val
}

// Ref: #/components/schemas/Meta
type Meta struct {
        Pagination OptMetaPagination `json:"pagination"`
}

// GetPagination returns the value of Pagination.
func (s *Meta) GetPagination() OptMetaPagination {
        return s.Pagination
}

// SetPagination sets the value of Pagination.
func (s *Meta) SetPagination(val OptMetaPagination) {
        s.Pagination = val
}

type MetaPagination struct {
        Total       OptInt `json:"total"`
        Count       OptInt `json:"count"`
        PerPage     OptInt `json:"per_page"`
        CurrentPage OptInt `json:"current_page"`
        TotalPages  OptInt `json:"total_pages"`
}

// GetTotal returns the value of Total.
func (s *MetaPagination) GetTotal() OptInt {
        return s.Total
}

// GetCount returns the value of Count.
func (s *MetaPagination) GetCount() OptInt {
        return s.Count
}

// GetPerPage returns the value of PerPage.
func (s *MetaPagination) GetPerPage() OptInt {
        return s.PerPage
}

// GetCurrentPage returns the value of CurrentPage.
func (s *MetaPagination) GetCurrentPage() OptInt {
        return s.CurrentPage
}

// GetTotalPages returns the value of TotalPages.
func (s *MetaPagination) GetTotalPages() OptInt {
        return s.TotalPages
}

// SetTotal sets the value of Total.
func (s *MetaPagination) SetTotal(val OptInt) {
        s.Total = val
}

// SetCount sets the value of Count.
func (s *MetaPagination) SetCount(val OptInt) {
        s.Count = val
}

// SetPerPage sets the value of PerPage.
func (s *MetaPagination) SetPerPage(val OptInt) {
        s.PerPage = val
}

// SetCurrentPage sets the value of CurrentPage.
func (s *MetaPagination) SetCurrentPage(val OptInt) {
        s.CurrentPage = val
}

// SetTotalPages sets the value of TotalPages.
func (s *MetaPagination) SetTotalPages(val OptInt) {
        s.TotalPages = val
}

// NewNilDate returns new NilDate with value set to v.
func NewNilDate(v time.Time) NilDate {
        return NilDate{
                Value: v,
        }
}

// NilDate is nullable time.Time.
type NilDate struct {
        Value time.Time
        Null  bool
}

// SetTo sets value to v.
func (o *NilDate) SetTo(v time.Time) {
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o NilDate) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *NilDate) SetToNull() {
        o.Null = true
        var v time.Time
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o NilDate) Get() (v time.Time, ok bool) {
        if o.Null {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o NilDate) Or(d time.Time) time.Time {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewNilString returns new NilString with value set to v.
func NewNilString(v string) NilString {
        return NilString{
                Value: v,
        }
}

// NilString is nullable string.
type NilString struct {
        Value string
        Null  bool
}

// SetTo sets value to v.
func (o *NilString) SetTo(v string) {
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o NilString) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *NilString) SetToNull() {
        o.Null = true
        var v string
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o NilString) Get() (v string, ok bool) {
        if o.Null {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o NilString) Or(d string) string {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// Ref: #/components/schemas/NotFound
type NotFound struct {
        Message   OptString `json:"message"`
        Exception OptString `json:"exception"`
}

// GetMessage returns the value of Message.
func (s *NotFound) GetMessage() OptString {
        return s.Message
}

// GetException returns the value of Exception.
func (s *NotFound) GetException() OptString {
        return s.Exception
}

// SetMessage sets the value of Message.
func (s *NotFound) SetMessage(val OptString) {
        s.Message = val
}

// SetException sets the value of Exception.
func (s *NotFound) SetException(val OptString) {
        s.Exception = val
}

func (*NotFound) bulkUpdateTransactionsRes()         {}
func (*NotFound) defaultCurrencyRes()                {}
func (*NotFound) deleteAccountRes()                  {}
func (*NotFound) deleteAttachmentRes()               {}
func (*NotFound) deleteBillRes()                     {}
func (*NotFound) deleteBudgetLimitRes()              {}
func (*NotFound) deleteBudgetRes()                   {}
func (*NotFound) deleteCategoryRes()                 {}
func (*NotFound) deleteCurrencyRes()                 {}
func (*NotFound) deleteLinkTypeRes()                 {}
func (*NotFound) deleteObjectGroupRes()              {}
func (*NotFound) deletePiggyBankRes()                {}
func (*NotFound) deleteRecurrenceRes()               {}
func (*NotFound) deleteRuleGroupRes()                {}
func (*NotFound) deleteRuleRes()                     {}
func (*NotFound) deleteTagRes()                      {}
func (*NotFound) deleteTransactionJournalRes()       {}
func (*NotFound) deleteTransactionLinkRes()          {}
func (*NotFound) deleteTransactionRes()              {}
func (*NotFound) deleteUserRes()                     {}
func (*NotFound) deleteWebhookMessageAttemptRes()    {}
func (*NotFound) deleteWebhookMessageRes()           {}
func (*NotFound) deleteWebhookRes()                  {}
func (*NotFound) destroyDataRes()                    {}
func (*NotFound) disableCurrencyRes()                {}
func (*NotFound) downloadAttachmentRes()             {}
func (*NotFound) enableCurrencyRes()                 {}
func (*NotFound) exportAccountsRes()                 {}
func (*NotFound) exportBillsRes()                    {}
func (*NotFound) exportBudgetsRes()                  {}
func (*NotFound) exportCategoriesRes()               {}
func (*NotFound) exportPiggiesRes()                  {}
func (*NotFound) exportRecurringRes()                {}
func (*NotFound) exportRulesRes()                    {}
func (*NotFound) exportTagsRes()                     {}
func (*NotFound) exportTransactionsRes()             {}
func (*NotFound) fireRuleGroupRes()                  {}
func (*NotFound) fireRuleRes()                       {}
func (*NotFound) getAboutRes()                       {}
func (*NotFound) getAccountRes()                     {}
func (*NotFound) getAccountsACRes()                  {}
func (*NotFound) getAttachmentRes()                  {}
func (*NotFound) getAvailableBudgetRes()             {}
func (*NotFound) getBasicSummaryRes()                {}
func (*NotFound) getBillRes()                        {}
func (*NotFound) getBillsACRes()                     {}
func (*NotFound) getBudgetLimitRes()                 {}
func (*NotFound) getBudgetRes()                      {}
func (*NotFound) getBudgetsACRes()                   {}
func (*NotFound) getCategoriesACRes()                {}
func (*NotFound) getCategoryRes()                    {}
func (*NotFound) getChartAccountOverviewRes()        {}
func (*NotFound) getConfigurationRes()               {}
func (*NotFound) getCronRes()                        {}
func (*NotFound) getCurrenciesACRes()                {}
func (*NotFound) getCurrenciesCodeACRes()            {}
func (*NotFound) getCurrencyRes()                    {}
func (*NotFound) getCurrentUserRes()                 {}
func (*NotFound) getDefaultCurrencyRes()             {}
func (*NotFound) getLinkTypeRes()                    {}
func (*NotFound) getObjectGroupRes()                 {}
func (*NotFound) getObjectGroupsACRes()              {}
func (*NotFound) getPiggiesACRes()                   {}
func (*NotFound) getPiggiesBalanceACRes()            {}
func (*NotFound) getPiggyBankRes()                   {}
func (*NotFound) getPreferenceRes()                  {}
func (*NotFound) getRecurrenceRes()                  {}
func (*NotFound) getRecurringACRes()                 {}
func (*NotFound) getRuleGroupRes()                   {}
func (*NotFound) getRuleGroupsACRes()                {}
func (*NotFound) getRuleRes()                        {}
func (*NotFound) getRulesACRes()                     {}
func (*NotFound) getSingleConfigurationRes()         {}
func (*NotFound) getSingleWebhookMessageAttemptRes() {}
func (*NotFound) getSingleWebhookMessageRes()        {}
func (*NotFound) getTagACRes()                       {}
func (*NotFound) getTagRes()                         {}
func (*NotFound) getTransactionByJournalRes()        {}
func (*NotFound) getTransactionLinkRes()             {}
func (*NotFound) getTransactionRes()                 {}
func (*NotFound) getTransactionTypesACRes()          {}
func (*NotFound) getTransactionsACRes()              {}
func (*NotFound) getTransactionsIDACRes()            {}
func (*NotFound) getUserRes()                        {}
func (*NotFound) getWebhookMessageAttemptsRes()      {}
func (*NotFound) getWebhookMessagesRes()             {}
func (*NotFound) getWebhookRes()                     {}
func (*NotFound) insightExpenseAssetRes()            {}
func (*NotFound) insightExpenseBillRes()             {}
func (*NotFound) insightExpenseBudgetRes()           {}
func (*NotFound) insightExpenseCategoryRes()         {}
func (*NotFound) insightExpenseExpenseRes()          {}
func (*NotFound) insightExpenseNoBillRes()           {}
func (*NotFound) insightExpenseNoBudgetRes()         {}
func (*NotFound) insightExpenseNoCategoryRes()       {}
func (*NotFound) insightExpenseNoTagRes()            {}
func (*NotFound) insightExpenseTagRes()              {}
func (*NotFound) insightExpenseTotalRes()            {}
func (*NotFound) insightIncomeAssetRes()             {}
func (*NotFound) insightIncomeCategoryRes()          {}
func (*NotFound) insightIncomeNoCategoryRes()        {}
func (*NotFound) insightIncomeNoTagRes()             {}
func (*NotFound) insightIncomeRevenueRes()           {}
func (*NotFound) insightIncomeTagRes()               {}
func (*NotFound) insightIncomeTotalRes()             {}
func (*NotFound) insightTransferCategoryRes()        {}
func (*NotFound) insightTransferNoCategoryRes()      {}
func (*NotFound) insightTransferNoTagRes()           {}
func (*NotFound) insightTransferTagRes()             {}
func (*NotFound) insightTransferTotalRes()           {}
func (*NotFound) insightTransfersRes()               {}
func (*NotFound) listAccountByCurrencyRes()          {}
func (*NotFound) listAccountRes()                    {}
func (*NotFound) listAttachmentByAccountRes()        {}
func (*NotFound) listAttachmentByBillRes()           {}
func (*NotFound) listAttachmentByBudgetRes()         {}
func (*NotFound) listAttachmentByCategoryRes()       {}
func (*NotFound) listAttachmentByPiggyBankRes()      {}
func (*NotFound) listAttachmentByTagRes()            {}
func (*NotFound) listAttachmentByTransactionRes()    {}
func (*NotFound) listAttachmentRes()                 {}
func (*NotFound) listAvailableBudgetByCurrencyRes()  {}
func (*NotFound) listAvailableBudgetRes()            {}
func (*NotFound) listBillByCurrencyRes()             {}
func (*NotFound) listBillByObjectGroupRes()          {}
func (*NotFound) listBillRes()                       {}
func (*NotFound) listBudgetLimitByBudgetRes()        {}
func (*NotFound) listBudgetLimitByCurrencyRes()      {}
func (*NotFound) listBudgetLimitRes()                {}
func (*NotFound) listBudgetRes()                     {}
func (*NotFound) listCategoryRes()                   {}
func (*NotFound) listCurrencyRes()                   {}
func (*NotFound) listEventByPiggyBankRes()           {}
func (*NotFound) listEventByTransactionRes()         {}
func (*NotFound) listLinkTypeRes()                   {}
func (*NotFound) listLinksByJournalRes()             {}
func (*NotFound) listObjectGroupsRes()               {}
func (*NotFound) listPiggyBankByAccountRes()         {}
func (*NotFound) listPiggyBankByObjectGroupRes()     {}
func (*NotFound) listPiggyBankRes()                  {}
func (*NotFound) listPreferenceRes()                 {}
func (*NotFound) listRecurrenceByCurrencyRes()       {}
func (*NotFound) listRecurrenceRes()                 {}
func (*NotFound) listRuleByBillRes()                 {}
func (*NotFound) listRuleByCurrencyRes()             {}
func (*NotFound) listRuleByGroupRes()                {}
func (*NotFound) listRuleGroupRes()                  {}
func (*NotFound) listRuleRes()                       {}
func (*NotFound) listTagRes()                        {}
func (*NotFound) listTransactionByAccountRes()       {}
func (*NotFound) listTransactionByBillRes()          {}
func (*NotFound) listTransactionByBudgetLimitRes()   {}
func (*NotFound) listTransactionByBudgetRes()        {}
func (*NotFound) listTransactionByCategoryRes()      {}
func (*NotFound) listTransactionByCurrencyRes()      {}
func (*NotFound) listTransactionByLinkTypeRes()      {}
func (*NotFound) listTransactionByRecurrenceRes()    {}
func (*NotFound) listTransactionByTagRes()           {}
func (*NotFound) listTransactionLinkRes()            {}
func (*NotFound) listTransactionRes()                {}
func (*NotFound) listUserRes()                       {}
func (*NotFound) listWebhookRes()                    {}
func (*NotFound) searchAccountsRes()                 {}
func (*NotFound) searchTransactionsRes()             {}
func (*NotFound) setConfigurationRes()               {}
func (*NotFound) storeAccountRes()                   {}
func (*NotFound) storeAttachmentRes()                {}
func (*NotFound) storeBillRes()                      {}
func (*NotFound) storeBudgetLimitRes()               {}
func (*NotFound) storeBudgetRes()                    {}
func (*NotFound) storeCategoryRes()                  {}
func (*NotFound) storeCurrencyRes()                  {}
func (*NotFound) storeLinkTypeRes()                  {}
func (*NotFound) storePiggyBankRes()                 {}
func (*NotFound) storePreferenceRes()                {}
func (*NotFound) storeRecurrenceRes()                {}
func (*NotFound) storeRuleGroupRes()                 {}
func (*NotFound) storeRuleRes()                      {}
func (*NotFound) storeTagRes()                       {}
func (*NotFound) storeTransactionLinkRes()           {}
func (*NotFound) storeTransactionRes()               {}
func (*NotFound) storeUserRes()                      {}
func (*NotFound) storeWebhookRes()                   {}
func (*NotFound) testRuleGroupRes()                  {}
func (*NotFound) testRuleRes()                       {}
func (*NotFound) updateAccountRes()                  {}
func (*NotFound) updateAttachmentRes()               {}
func (*NotFound) updateBillRes()                     {}
func (*NotFound) updateBudgetLimitRes()              {}
func (*NotFound) updateBudgetRes()                   {}
func (*NotFound) updateCategoryRes()                 {}
func (*NotFound) updateCurrencyRes()                 {}
func (*NotFound) updateLinkTypeRes()                 {}
func (*NotFound) updateObjectGroupRes()              {}
func (*NotFound) updatePiggyBankRes()                {}
func (*NotFound) updatePreferenceRes()               {}
func (*NotFound) updateRecurrenceRes()               {}
func (*NotFound) updateRuleGroupRes()                {}
func (*NotFound) updateRuleRes()                     {}
func (*NotFound) updateTagRes()                      {}
func (*NotFound) updateTransactionLinkRes()          {}
func (*NotFound) updateTransactionRes()              {}
func (*NotFound) updateUserRes()                     {}
func (*NotFound) updateWebhookRes()                  {}
func (*NotFound) uploadAttachmentRes()               {}

// Ref: #/components/schemas/ObjectGroup
type ObjectGroup struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        Title     string      `json:"title"`
        // Order of the object group.
        Order int32 `json:"order"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *ObjectGroup) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *ObjectGroup) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetTitle returns the value of Title.
func (s *ObjectGroup) GetTitle() string {
        return s.Title
}

// GetOrder returns the value of Order.
func (s *ObjectGroup) GetOrder() int32 {
        return s.Order
}

// SetCreatedAt sets the value of CreatedAt.
func (s *ObjectGroup) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *ObjectGroup) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetTitle sets the value of Title.
func (s *ObjectGroup) SetTitle(val string) {
        s.Title = val
}

// SetOrder sets the value of Order.
func (s *ObjectGroup) SetOrder(val int32) {
        s.Order = val
}

// Ref: #/components/schemas/ObjectGroupArray
type ObjectGroupArray struct {
        Data []ObjectGroupRead `json:"data"`
        Meta Meta              `json:"meta"`
}

// GetData returns the value of Data.
func (s *ObjectGroupArray) GetData() []ObjectGroupRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *ObjectGroupArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *ObjectGroupArray) SetData(val []ObjectGroupRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *ObjectGroupArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*ObjectGroupArray) listObjectGroupsRes() {}

// Ref: #/components/schemas/ObjectGroupRead
type ObjectGroupRead struct {
        // Immutable value.
        Type       string      `json:"type"`
        ID         string      `json:"id"`
        Attributes ObjectGroup `json:"attributes"`
}

// GetType returns the value of Type.
func (s *ObjectGroupRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *ObjectGroupRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *ObjectGroupRead) GetAttributes() ObjectGroup {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *ObjectGroupRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *ObjectGroupRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *ObjectGroupRead) SetAttributes(val ObjectGroup) {
        s.Attributes = val
}

// Ref: #/components/schemas/ObjectGroupSingle
type ObjectGroupSingle struct {
        Data ObjectGroupRead `json:"data"`
}

// GetData returns the value of Data.
func (s *ObjectGroupSingle) GetData() ObjectGroupRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *ObjectGroupSingle) SetData(val ObjectGroupRead) {
        s.Data = val
}

func (*ObjectGroupSingle) getObjectGroupRes()    {}
func (*ObjectGroupSingle) updateObjectGroupRes() {}

// Ref: #/components/schemas/ObjectGroupUpdate
type ObjectGroupUpdate struct {
        Title string `json:"title"`
        // Order of the object group.
        Order OptInt32 `json:"order"`
}

// GetTitle returns the value of Title.
func (s *ObjectGroupUpdate) GetTitle() string {
        return s.Title
}

// GetOrder returns the value of Order.
func (s *ObjectGroupUpdate) GetOrder() OptInt32 {
        return s.Order
}

// SetTitle sets the value of Title.
func (s *ObjectGroupUpdate) SetTitle(val string) {
        s.Title = val
}

// SetOrder sets the value of Order.
func (s *ObjectGroupUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// Ref: #/components/schemas/ObjectLink
type ObjectLink struct {
        R0   OptObjectLink0 `json:"0"`
        Self OptURI         `json:"self"`
}

// GetR0 returns the value of R0.
func (s *ObjectLink) GetR0() OptObjectLink0 {
        return s.R0
}

// GetSelf returns the value of Self.
func (s *ObjectLink) GetSelf() OptURI {
        return s.Self
}

// SetR0 sets the value of R0.
func (s *ObjectLink) SetR0(val OptObjectLink0) {
        s.R0 = val
}

// SetSelf sets the value of Self.
func (s *ObjectLink) SetSelf(val OptURI) {
        s.Self = val
}

type ObjectLink0 struct {
        Rel OptString `json:"rel"`
        URI OptString `json:"uri"`
}

// GetRel returns the value of Rel.
func (s *ObjectLink0) GetRel() OptString {
        return s.Rel
}

// GetURI returns the value of URI.
func (s *ObjectLink0) GetURI() OptString {
        return s.URI
}

// SetRel sets the value of Rel.
func (s *ObjectLink0) SetRel(val OptString) {
        s.Rel = val
}

// SetURI sets the value of URI.
func (s *ObjectLink0) SetURI(val OptString) {
        s.URI = val
}

// NewOptAccountTypeFilter returns new OptAccountTypeFilter with value set to v.
func NewOptAccountTypeFilter(v AccountTypeFilter) OptAccountTypeFilter {
        return OptAccountTypeFilter{
                Value: v,
                Set:   true,
        }
}

// OptAccountTypeFilter is optional AccountTypeFilter.
type OptAccountTypeFilter struct {
        Value AccountTypeFilter
        Set   bool
}

// IsSet returns true if OptAccountTypeFilter was set.
func (o OptAccountTypeFilter) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptAccountTypeFilter) Reset() {
        var v AccountTypeFilter
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptAccountTypeFilter) SetTo(v AccountTypeFilter) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptAccountTypeFilter) Get() (v AccountTypeFilter, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptAccountTypeFilter) Or(d AccountTypeFilter) AccountTypeFilter {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptAccountTypeProperty returns new OptAccountTypeProperty with value set to v.
func NewOptAccountTypeProperty(v AccountTypeProperty) OptAccountTypeProperty {
        return OptAccountTypeProperty{
                Value: v,
                Set:   true,
        }
}

// OptAccountTypeProperty is optional AccountTypeProperty.
type OptAccountTypeProperty struct {
        Value AccountTypeProperty
        Set   bool
}

// IsSet returns true if OptAccountTypeProperty was set.
func (o OptAccountTypeProperty) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptAccountTypeProperty) Reset() {
        var v AccountTypeProperty
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptAccountTypeProperty) SetTo(v AccountTypeProperty) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptAccountTypeProperty) Get() (v AccountTypeProperty, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptAccountTypeProperty) Or(d AccountTypeProperty) AccountTypeProperty {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptBillRepeatFrequency returns new OptBillRepeatFrequency with value set to v.
func NewOptBillRepeatFrequency(v BillRepeatFrequency) OptBillRepeatFrequency {
        return OptBillRepeatFrequency{
                Value: v,
                Set:   true,
        }
}

// OptBillRepeatFrequency is optional BillRepeatFrequency.
type OptBillRepeatFrequency struct {
        Value BillRepeatFrequency
        Set   bool
}

// IsSet returns true if OptBillRepeatFrequency was set.
func (o OptBillRepeatFrequency) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptBillRepeatFrequency) Reset() {
        var v BillRepeatFrequency
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptBillRepeatFrequency) SetTo(v BillRepeatFrequency) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptBillRepeatFrequency) Get() (v BillRepeatFrequency, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptBillRepeatFrequency) Or(d BillRepeatFrequency) BillRepeatFrequency {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptBool returns new OptBool with value set to v.
func NewOptBool(v bool) OptBool {
        return OptBool{
                Value: v,
                Set:   true,
        }
}

// OptBool is optional bool.
type OptBool struct {
        Value bool
        Set   bool
}

// IsSet returns true if OptBool was set.
func (o OptBool) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptBool) Reset() {
        var v bool
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptBool) SetTo(v bool) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptBool) Get() (v bool, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptBool) Or(d bool) bool {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptChartDataSetEntries returns new OptChartDataSetEntries with value set to v.
func NewOptChartDataSetEntries(v ChartDataSetEntries) OptChartDataSetEntries {
        return OptChartDataSetEntries{
                Value: v,
                Set:   true,
        }
}

// OptChartDataSetEntries is optional ChartDataSetEntries.
type OptChartDataSetEntries struct {
        Value ChartDataSetEntries
        Set   bool
}

// IsSet returns true if OptChartDataSetEntries was set.
func (o OptChartDataSetEntries) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptChartDataSetEntries) Reset() {
        var v ChartDataSetEntries
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptChartDataSetEntries) SetTo(v ChartDataSetEntries) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptChartDataSetEntries) Get() (v ChartDataSetEntries, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptChartDataSetEntries) Or(d ChartDataSetEntries) ChartDataSetEntries {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptCronResultRow returns new OptCronResultRow with value set to v.
func NewOptCronResultRow(v CronResultRow) OptCronResultRow {
        return OptCronResultRow{
                Value: v,
                Set:   true,
        }
}

// OptCronResultRow is optional CronResultRow.
type OptCronResultRow struct {
        Value CronResultRow
        Set   bool
}

// IsSet returns true if OptCronResultRow was set.
func (o OptCronResultRow) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptCronResultRow) Reset() {
        var v CronResultRow
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptCronResultRow) SetTo(v CronResultRow) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptCronResultRow) Get() (v CronResultRow, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptCronResultRow) Or(d CronResultRow) CronResultRow {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptCurrencyUpdateDefault returns new OptCurrencyUpdateDefault with value set to v.
func NewOptCurrencyUpdateDefault(v CurrencyUpdateDefault) OptCurrencyUpdateDefault {
        return OptCurrencyUpdateDefault{
                Value: v,
                Set:   true,
        }
}

// OptCurrencyUpdateDefault is optional CurrencyUpdateDefault.
type OptCurrencyUpdateDefault struct {
        Value CurrencyUpdateDefault
        Set   bool
}

// IsSet returns true if OptCurrencyUpdateDefault was set.
func (o OptCurrencyUpdateDefault) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptCurrencyUpdateDefault) Reset() {
        var v CurrencyUpdateDefault
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptCurrencyUpdateDefault) SetTo(v CurrencyUpdateDefault) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptCurrencyUpdateDefault) Get() (v CurrencyUpdateDefault, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptCurrencyUpdateDefault) Or(d CurrencyUpdateDefault) CurrencyUpdateDefault {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptDate returns new OptDate with value set to v.
func NewOptDate(v time.Time) OptDate {
        return OptDate{
                Value: v,
                Set:   true,
        }
}

// OptDate is optional time.Time.
type OptDate struct {
        Value time.Time
        Set   bool
}

// IsSet returns true if OptDate was set.
func (o OptDate) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptDate) Reset() {
        var v time.Time
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptDate) SetTo(v time.Time) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptDate) Get() (v time.Time, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptDate) Or(d time.Time) time.Time {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptDateTime returns new OptDateTime with value set to v.
func NewOptDateTime(v time.Time) OptDateTime {
        return OptDateTime{
                Value: v,
                Set:   true,
        }
}

// OptDateTime is optional time.Time.
type OptDateTime struct {
        Value time.Time
        Set   bool
}

// IsSet returns true if OptDateTime was set.
func (o OptDateTime) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptDateTime) Reset() {
        var v time.Time
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptDateTime) SetTo(v time.Time) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptDateTime) Get() (v time.Time, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptDateTime) Or(d time.Time) time.Time {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptExportFileFilter returns new OptExportFileFilter with value set to v.
func NewOptExportFileFilter(v ExportFileFilter) OptExportFileFilter {
        return OptExportFileFilter{
                Value: v,
                Set:   true,
        }
}

// OptExportFileFilter is optional ExportFileFilter.
type OptExportFileFilter struct {
        Value ExportFileFilter
        Set   bool
}

// IsSet returns true if OptExportFileFilter was set.
func (o OptExportFileFilter) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptExportFileFilter) Reset() {
        var v ExportFileFilter
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptExportFileFilter) SetTo(v ExportFileFilter) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptExportFileFilter) Get() (v ExportFileFilter, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptExportFileFilter) Or(d ExportFileFilter) ExportFileFilter {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptFloat64 returns new OptFloat64 with value set to v.
func NewOptFloat64(v float64) OptFloat64 {
        return OptFloat64{
                Value: v,
                Set:   true,
        }
}

// OptFloat64 is optional float64.
type OptFloat64 struct {
        Value float64
        Set   bool
}

// IsSet returns true if OptFloat64 was set.
func (o OptFloat64) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptFloat64) Reset() {
        var v float64
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptFloat64) SetTo(v float64) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptFloat64) Get() (v float64, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptFloat64) Or(d float64) float64 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptInt returns new OptInt with value set to v.
func NewOptInt(v int) OptInt {
        return OptInt{
                Value: v,
                Set:   true,
        }
}

// OptInt is optional int.
type OptInt struct {
        Value int
        Set   bool
}

// IsSet returns true if OptInt was set.
func (o OptInt) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptInt) Reset() {
        var v int
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptInt) SetTo(v int) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptInt) Get() (v int, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptInt) Or(d int) int {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptInt32 returns new OptInt32 with value set to v.
func NewOptInt32(v int32) OptInt32 {
        return OptInt32{
                Value: v,
                Set:   true,
        }
}

// OptInt32 is optional int32.
type OptInt32 struct {
        Value int32
        Set   bool
}

// IsSet returns true if OptInt32 was set.
func (o OptInt32) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptInt32) Reset() {
        var v int32
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptInt32) SetTo(v int32) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptInt32) Get() (v int32, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptInt32) Or(d int32) int32 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptMetaPagination returns new OptMetaPagination with value set to v.
func NewOptMetaPagination(v MetaPagination) OptMetaPagination {
        return OptMetaPagination{
                Value: v,
                Set:   true,
        }
}

// OptMetaPagination is optional MetaPagination.
type OptMetaPagination struct {
        Value MetaPagination
        Set   bool
}

// IsSet returns true if OptMetaPagination was set.
func (o OptMetaPagination) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptMetaPagination) Reset() {
        var v MetaPagination
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptMetaPagination) SetTo(v MetaPagination) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptMetaPagination) Get() (v MetaPagination, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptMetaPagination) Or(d MetaPagination) MetaPagination {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilAccountRoleProperty returns new OptNilAccountRoleProperty with value set to v.
func NewOptNilAccountRoleProperty(v AccountRoleProperty) OptNilAccountRoleProperty {
        return OptNilAccountRoleProperty{
                Value: v,
                Set:   true,
        }
}

// OptNilAccountRoleProperty is optional nullable AccountRoleProperty.
type OptNilAccountRoleProperty struct {
        Value AccountRoleProperty
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilAccountRoleProperty was set.
func (o OptNilAccountRoleProperty) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilAccountRoleProperty) Reset() {
        var v AccountRoleProperty
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilAccountRoleProperty) SetTo(v AccountRoleProperty) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilAccountRoleProperty) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilAccountRoleProperty) SetToNull() {
        o.Set = true
        o.Null = true
        var v AccountRoleProperty
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilAccountRoleProperty) Get() (v AccountRoleProperty, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilAccountRoleProperty) Or(d AccountRoleProperty) AccountRoleProperty {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilAutoBudgetPeriod returns new OptNilAutoBudgetPeriod with value set to v.
func NewOptNilAutoBudgetPeriod(v AutoBudgetPeriod) OptNilAutoBudgetPeriod {
        return OptNilAutoBudgetPeriod{
                Value: v,
                Set:   true,
        }
}

// OptNilAutoBudgetPeriod is optional nullable AutoBudgetPeriod.
type OptNilAutoBudgetPeriod struct {
        Value AutoBudgetPeriod
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilAutoBudgetPeriod was set.
func (o OptNilAutoBudgetPeriod) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilAutoBudgetPeriod) Reset() {
        var v AutoBudgetPeriod
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilAutoBudgetPeriod) SetTo(v AutoBudgetPeriod) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilAutoBudgetPeriod) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilAutoBudgetPeriod) SetToNull() {
        o.Set = true
        o.Null = true
        var v AutoBudgetPeriod
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilAutoBudgetPeriod) Get() (v AutoBudgetPeriod, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilAutoBudgetPeriod) Or(d AutoBudgetPeriod) AutoBudgetPeriod {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilAutoBudgetType returns new OptNilAutoBudgetType with value set to v.
func NewOptNilAutoBudgetType(v AutoBudgetType) OptNilAutoBudgetType {
        return OptNilAutoBudgetType{
                Value: v,
                Set:   true,
        }
}

// OptNilAutoBudgetType is optional nullable AutoBudgetType.
type OptNilAutoBudgetType struct {
        Value AutoBudgetType
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilAutoBudgetType was set.
func (o OptNilAutoBudgetType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilAutoBudgetType) Reset() {
        var v AutoBudgetType
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilAutoBudgetType) SetTo(v AutoBudgetType) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilAutoBudgetType) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilAutoBudgetType) SetToNull() {
        o.Set = true
        o.Null = true
        var v AutoBudgetType
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilAutoBudgetType) Get() (v AutoBudgetType, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilAutoBudgetType) Or(d AutoBudgetType) AutoBudgetType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilBool returns new OptNilBool with value set to v.
func NewOptNilBool(v bool) OptNilBool {
        return OptNilBool{
                Value: v,
                Set:   true,
        }
}

// OptNilBool is optional nullable bool.
type OptNilBool struct {
        Value bool
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilBool was set.
func (o OptNilBool) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilBool) Reset() {
        var v bool
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilBool) SetTo(v bool) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilBool) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilBool) SetToNull() {
        o.Set = true
        o.Null = true
        var v bool
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilBool) Get() (v bool, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilBool) Or(d bool) bool {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilCreditCardType returns new OptNilCreditCardType with value set to v.
func NewOptNilCreditCardType(v CreditCardType) OptNilCreditCardType {
        return OptNilCreditCardType{
                Value: v,
                Set:   true,
        }
}

// OptNilCreditCardType is optional nullable CreditCardType.
type OptNilCreditCardType struct {
        Value CreditCardType
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilCreditCardType was set.
func (o OptNilCreditCardType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilCreditCardType) Reset() {
        var v CreditCardType
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilCreditCardType) SetTo(v CreditCardType) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilCreditCardType) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilCreditCardType) SetToNull() {
        o.Set = true
        o.Null = true
        var v CreditCardType
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilCreditCardType) Get() (v CreditCardType, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilCreditCardType) Or(d CreditCardType) CreditCardType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilDate returns new OptNilDate with value set to v.
func NewOptNilDate(v time.Time) OptNilDate {
        return OptNilDate{
                Value: v,
                Set:   true,
        }
}

// OptNilDate is optional nullable time.Time.
type OptNilDate struct {
        Value time.Time
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilDate was set.
func (o OptNilDate) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilDate) Reset() {
        var v time.Time
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilDate) SetTo(v time.Time) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilDate) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilDate) SetToNull() {
        o.Set = true
        o.Null = true
        var v time.Time
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilDate) Get() (v time.Time, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilDate) Or(d time.Time) time.Time {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilDateTime returns new OptNilDateTime with value set to v.
func NewOptNilDateTime(v time.Time) OptNilDateTime {
        return OptNilDateTime{
                Value: v,
                Set:   true,
        }
}

// OptNilDateTime is optional nullable time.Time.
type OptNilDateTime struct {
        Value time.Time
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilDateTime was set.
func (o OptNilDateTime) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilDateTime) Reset() {
        var v time.Time
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilDateTime) SetTo(v time.Time) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilDateTime) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilDateTime) SetToNull() {
        o.Set = true
        o.Null = true
        var v time.Time
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilDateTime) Get() (v time.Time, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilDateTime) Or(d time.Time) time.Time {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilFloat32 returns new OptNilFloat32 with value set to v.
func NewOptNilFloat32(v float32) OptNilFloat32 {
        return OptNilFloat32{
                Value: v,
                Set:   true,
        }
}

// OptNilFloat32 is optional nullable float32.
type OptNilFloat32 struct {
        Value float32
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilFloat32 was set.
func (o OptNilFloat32) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilFloat32) Reset() {
        var v float32
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilFloat32) SetTo(v float32) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilFloat32) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilFloat32) SetToNull() {
        o.Set = true
        o.Null = true
        var v float32
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilFloat32) Get() (v float32, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilFloat32) Or(d float32) float32 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilFloat64 returns new OptNilFloat64 with value set to v.
func NewOptNilFloat64(v float64) OptNilFloat64 {
        return OptNilFloat64{
                Value: v,
                Set:   true,
        }
}

// OptNilFloat64 is optional nullable float64.
type OptNilFloat64 struct {
        Value float64
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilFloat64 was set.
func (o OptNilFloat64) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilFloat64) Reset() {
        var v float64
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilFloat64) SetTo(v float64) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilFloat64) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilFloat64) SetToNull() {
        o.Set = true
        o.Null = true
        var v float64
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilFloat64) Get() (v float64, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilFloat64) Or(d float64) float64 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilInt32 returns new OptNilInt32 with value set to v.
func NewOptNilInt32(v int32) OptNilInt32 {
        return OptNilInt32{
                Value: v,
                Set:   true,
        }
}

// OptNilInt32 is optional nullable int32.
type OptNilInt32 struct {
        Value int32
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilInt32 was set.
func (o OptNilInt32) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilInt32) Reset() {
        var v int32
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilInt32) SetTo(v int32) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilInt32) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilInt32) SetToNull() {
        o.Set = true
        o.Null = true
        var v int32
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilInt32) Get() (v int32, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilInt32) Or(d int32) int32 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilInterestPeriod returns new OptNilInterestPeriod with value set to v.
func NewOptNilInterestPeriod(v InterestPeriod) OptNilInterestPeriod {
        return OptNilInterestPeriod{
                Value: v,
                Set:   true,
        }
}

// OptNilInterestPeriod is optional nullable InterestPeriod.
type OptNilInterestPeriod struct {
        Value InterestPeriod
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilInterestPeriod was set.
func (o OptNilInterestPeriod) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilInterestPeriod) Reset() {
        var v InterestPeriod
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilInterestPeriod) SetTo(v InterestPeriod) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilInterestPeriod) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilInterestPeriod) SetToNull() {
        o.Set = true
        o.Null = true
        var v InterestPeriod
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilInterestPeriod) Get() (v InterestPeriod, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilInterestPeriod) Or(d InterestPeriod) InterestPeriod {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilLiabilityDirection returns new OptNilLiabilityDirection with value set to v.
func NewOptNilLiabilityDirection(v LiabilityDirection) OptNilLiabilityDirection {
        return OptNilLiabilityDirection{
                Value: v,
                Set:   true,
        }
}

// OptNilLiabilityDirection is optional nullable LiabilityDirection.
type OptNilLiabilityDirection struct {
        Value LiabilityDirection
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilLiabilityDirection was set.
func (o OptNilLiabilityDirection) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilLiabilityDirection) Reset() {
        var v LiabilityDirection
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilLiabilityDirection) SetTo(v LiabilityDirection) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilLiabilityDirection) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilLiabilityDirection) SetToNull() {
        o.Set = true
        o.Null = true
        var v LiabilityDirection
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilLiabilityDirection) Get() (v LiabilityDirection, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilLiabilityDirection) Or(d LiabilityDirection) LiabilityDirection {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilLiabilityType returns new OptNilLiabilityType with value set to v.
func NewOptNilLiabilityType(v LiabilityType) OptNilLiabilityType {
        return OptNilLiabilityType{
                Value: v,
                Set:   true,
        }
}

// OptNilLiabilityType is optional nullable LiabilityType.
type OptNilLiabilityType struct {
        Value LiabilityType
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilLiabilityType was set.
func (o OptNilLiabilityType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilLiabilityType) Reset() {
        var v LiabilityType
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilLiabilityType) SetTo(v LiabilityType) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilLiabilityType) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilLiabilityType) SetToNull() {
        o.Set = true
        o.Null = true
        var v LiabilityType
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilLiabilityType) Get() (v LiabilityType, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilLiabilityType) Or(d LiabilityType) LiabilityType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilString returns new OptNilString with value set to v.
func NewOptNilString(v string) OptNilString {
        return OptNilString{
                Value: v,
                Set:   true,
        }
}

// OptNilString is optional nullable string.
type OptNilString struct {
        Value string
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilString was set.
func (o OptNilString) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilString) Reset() {
        var v string
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilString) SetTo(v string) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilString) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilString) SetToNull() {
        o.Set = true
        o.Null = true
        var v string
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilString) Get() (v string, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilString) Or(d string) string {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilStringArray returns new OptNilStringArray with value set to v.
func NewOptNilStringArray(v []string) OptNilStringArray {
        return OptNilStringArray{
                Value: v,
                Set:   true,
        }
}

// OptNilStringArray is optional nullable []string.
type OptNilStringArray struct {
        Value []string
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilStringArray was set.
func (o OptNilStringArray) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilStringArray) Reset() {
        var v []string
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilStringArray) SetTo(v []string) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilStringArray) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilStringArray) SetToNull() {
        o.Set = true
        o.Null = true
        var v []string
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilStringArray) Get() (v []string, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilStringArray) Or(d []string) []string {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilUserBlockedCodeProperty returns new OptNilUserBlockedCodeProperty with value set to v.
func NewOptNilUserBlockedCodeProperty(v UserBlockedCodeProperty) OptNilUserBlockedCodeProperty {
        return OptNilUserBlockedCodeProperty{
                Value: v,
                Set:   true,
        }
}

// OptNilUserBlockedCodeProperty is optional nullable UserBlockedCodeProperty.
type OptNilUserBlockedCodeProperty struct {
        Value UserBlockedCodeProperty
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilUserBlockedCodeProperty was set.
func (o OptNilUserBlockedCodeProperty) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilUserBlockedCodeProperty) Reset() {
        var v UserBlockedCodeProperty
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilUserBlockedCodeProperty) SetTo(v UserBlockedCodeProperty) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilUserBlockedCodeProperty) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilUserBlockedCodeProperty) SetToNull() {
        o.Set = true
        o.Null = true
        var v UserBlockedCodeProperty
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilUserBlockedCodeProperty) Get() (v UserBlockedCodeProperty, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilUserBlockedCodeProperty) Or(d UserBlockedCodeProperty) UserBlockedCodeProperty {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptNilUserRoleProperty returns new OptNilUserRoleProperty with value set to v.
func NewOptNilUserRoleProperty(v UserRoleProperty) OptNilUserRoleProperty {
        return OptNilUserRoleProperty{
                Value: v,
                Set:   true,
        }
}

// OptNilUserRoleProperty is optional nullable UserRoleProperty.
type OptNilUserRoleProperty struct {
        Value UserRoleProperty
        Set   bool
        Null  bool
}

// IsSet returns true if OptNilUserRoleProperty was set.
func (o OptNilUserRoleProperty) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptNilUserRoleProperty) Reset() {
        var v UserRoleProperty
        o.Value = v
        o.Set = false
        o.Null = false
}

// SetTo sets value to v.
func (o *OptNilUserRoleProperty) SetTo(v UserRoleProperty) {
        o.Set = true
        o.Null = false
        o.Value = v
}

// IsSet returns true if value is Null.
func (o OptNilUserRoleProperty) IsNull() bool { return o.Null }

// SetNull sets value to null.
func (o *OptNilUserRoleProperty) SetToNull() {
        o.Set = true
        o.Null = true
        var v UserRoleProperty
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptNilUserRoleProperty) Get() (v UserRoleProperty, ok bool) {
        if o.Null {
                return v, false
        }
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptNilUserRoleProperty) Or(d UserRoleProperty) UserRoleProperty {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptObjectLink0 returns new OptObjectLink0 with value set to v.
func NewOptObjectLink0(v ObjectLink0) OptObjectLink0 {
        return OptObjectLink0{
                Value: v,
                Set:   true,
        }
}

// OptObjectLink0 is optional ObjectLink0.
type OptObjectLink0 struct {
        Value ObjectLink0
        Set   bool
}

// IsSet returns true if OptObjectLink0 was set.
func (o OptObjectLink0) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptObjectLink0) Reset() {
        var v ObjectLink0
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptObjectLink0) SetTo(v ObjectLink0) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptObjectLink0) Get() (v ObjectLink0, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptObjectLink0) Or(d ObjectLink0) ObjectLink0 {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptRecurrenceRepetitionType returns new OptRecurrenceRepetitionType with value set to v.
func NewOptRecurrenceRepetitionType(v RecurrenceRepetitionType) OptRecurrenceRepetitionType {
        return OptRecurrenceRepetitionType{
                Value: v,
                Set:   true,
        }
}

// OptRecurrenceRepetitionType is optional RecurrenceRepetitionType.
type OptRecurrenceRepetitionType struct {
        Value RecurrenceRepetitionType
        Set   bool
}

// IsSet returns true if OptRecurrenceRepetitionType was set.
func (o OptRecurrenceRepetitionType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptRecurrenceRepetitionType) Reset() {
        var v RecurrenceRepetitionType
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptRecurrenceRepetitionType) SetTo(v RecurrenceRepetitionType) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptRecurrenceRepetitionType) Get() (v RecurrenceRepetitionType, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptRecurrenceRepetitionType) Or(d RecurrenceRepetitionType) RecurrenceRepetitionType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptRecurrenceTransactionType returns new OptRecurrenceTransactionType with value set to v.
func NewOptRecurrenceTransactionType(v RecurrenceTransactionType) OptRecurrenceTransactionType {
        return OptRecurrenceTransactionType{
                Value: v,
                Set:   true,
        }
}

// OptRecurrenceTransactionType is optional RecurrenceTransactionType.
type OptRecurrenceTransactionType struct {
        Value RecurrenceTransactionType
        Set   bool
}

// IsSet returns true if OptRecurrenceTransactionType was set.
func (o OptRecurrenceTransactionType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptRecurrenceTransactionType) Reset() {
        var v RecurrenceTransactionType
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptRecurrenceTransactionType) SetTo(v RecurrenceTransactionType) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptRecurrenceTransactionType) Get() (v RecurrenceTransactionType, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptRecurrenceTransactionType) Or(d RecurrenceTransactionType) RecurrenceTransactionType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptRuleActionKeyword returns new OptRuleActionKeyword with value set to v.
func NewOptRuleActionKeyword(v RuleActionKeyword) OptRuleActionKeyword {
        return OptRuleActionKeyword{
                Value: v,
                Set:   true,
        }
}

// OptRuleActionKeyword is optional RuleActionKeyword.
type OptRuleActionKeyword struct {
        Value RuleActionKeyword
        Set   bool
}

// IsSet returns true if OptRuleActionKeyword was set.
func (o OptRuleActionKeyword) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptRuleActionKeyword) Reset() {
        var v RuleActionKeyword
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptRuleActionKeyword) SetTo(v RuleActionKeyword) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptRuleActionKeyword) Get() (v RuleActionKeyword, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptRuleActionKeyword) Or(d RuleActionKeyword) RuleActionKeyword {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptRuleTriggerKeyword returns new OptRuleTriggerKeyword with value set to v.
func NewOptRuleTriggerKeyword(v RuleTriggerKeyword) OptRuleTriggerKeyword {
        return OptRuleTriggerKeyword{
                Value: v,
                Set:   true,
        }
}

// OptRuleTriggerKeyword is optional RuleTriggerKeyword.
type OptRuleTriggerKeyword struct {
        Value RuleTriggerKeyword
        Set   bool
}

// IsSet returns true if OptRuleTriggerKeyword was set.
func (o OptRuleTriggerKeyword) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptRuleTriggerKeyword) Reset() {
        var v RuleTriggerKeyword
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptRuleTriggerKeyword) SetTo(v RuleTriggerKeyword) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptRuleTriggerKeyword) Get() (v RuleTriggerKeyword, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptRuleTriggerKeyword) Or(d RuleTriggerKeyword) RuleTriggerKeyword {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptRuleTriggerType returns new OptRuleTriggerType with value set to v.
func NewOptRuleTriggerType(v RuleTriggerType) OptRuleTriggerType {
        return OptRuleTriggerType{
                Value: v,
                Set:   true,
        }
}

// OptRuleTriggerType is optional RuleTriggerType.
type OptRuleTriggerType struct {
        Value RuleTriggerType
        Set   bool
}

// IsSet returns true if OptRuleTriggerType was set.
func (o OptRuleTriggerType) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptRuleTriggerType) Reset() {
        var v RuleTriggerType
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptRuleTriggerType) SetTo(v RuleTriggerType) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptRuleTriggerType) Get() (v RuleTriggerType, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptRuleTriggerType) Or(d RuleTriggerType) RuleTriggerType {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptString returns new OptString with value set to v.
func NewOptString(v string) OptString {
        return OptString{
                Value: v,
                Set:   true,
        }
}

// OptString is optional string.
type OptString struct {
        Value string
        Set   bool
}

// IsSet returns true if OptString was set.
func (o OptString) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptString) Reset() {
        var v string
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptString) SetTo(v string) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptString) Get() (v string, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptString) Or(d string) string {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptSystemInfoData returns new OptSystemInfoData with value set to v.
func NewOptSystemInfoData(v SystemInfoData) OptSystemInfoData {
        return OptSystemInfoData{
                Value: v,
                Set:   true,
        }
}

// OptSystemInfoData is optional SystemInfoData.
type OptSystemInfoData struct {
        Value SystemInfoData
        Set   bool
}

// IsSet returns true if OptSystemInfoData was set.
func (o OptSystemInfoData) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptSystemInfoData) Reset() {
        var v SystemInfoData
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptSystemInfoData) SetTo(v SystemInfoData) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptSystemInfoData) Get() (v SystemInfoData, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptSystemInfoData) Or(d SystemInfoData) SystemInfoData {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptTransactionTypeFilter returns new OptTransactionTypeFilter with value set to v.
func NewOptTransactionTypeFilter(v TransactionTypeFilter) OptTransactionTypeFilter {
        return OptTransactionTypeFilter{
                Value: v,
                Set:   true,
        }
}

// OptTransactionTypeFilter is optional TransactionTypeFilter.
type OptTransactionTypeFilter struct {
        Value TransactionTypeFilter
        Set   bool
}

// IsSet returns true if OptTransactionTypeFilter was set.
func (o OptTransactionTypeFilter) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptTransactionTypeFilter) Reset() {
        var v TransactionTypeFilter
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptTransactionTypeFilter) SetTo(v TransactionTypeFilter) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptTransactionTypeFilter) Get() (v TransactionTypeFilter, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptTransactionTypeFilter) Or(d TransactionTypeFilter) TransactionTypeFilter {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptTransactionTypeProperty returns new OptTransactionTypeProperty with value set to v.
func NewOptTransactionTypeProperty(v TransactionTypeProperty) OptTransactionTypeProperty {
        return OptTransactionTypeProperty{
                Value: v,
                Set:   true,
        }
}

// OptTransactionTypeProperty is optional TransactionTypeProperty.
type OptTransactionTypeProperty struct {
        Value TransactionTypeProperty
        Set   bool
}

// IsSet returns true if OptTransactionTypeProperty was set.
func (o OptTransactionTypeProperty) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptTransactionTypeProperty) Reset() {
        var v TransactionTypeProperty
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptTransactionTypeProperty) SetTo(v TransactionTypeProperty) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptTransactionTypeProperty) Get() (v TransactionTypeProperty, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptTransactionTypeProperty) Or(d TransactionTypeProperty) TransactionTypeProperty {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptURI returns new OptURI with value set to v.
func NewOptURI(v url.URL) OptURI {
        return OptURI{
                Value: v,
                Set:   true,
        }
}

// OptURI is optional url.URL.
type OptURI struct {
        Value url.URL
        Set   bool
}

// IsSet returns true if OptURI was set.
func (o OptURI) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptURI) Reset() {
        var v url.URL
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptURI) SetTo(v url.URL) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptURI) Get() (v url.URL, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptURI) Or(d url.URL) url.URL {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptUUID returns new OptUUID with value set to v.
func NewOptUUID(v uuid.UUID) OptUUID {
        return OptUUID{
                Value: v,
                Set:   true,
        }
}

// OptUUID is optional uuid.UUID.
type OptUUID struct {
        Value uuid.UUID
        Set   bool
}

// IsSet returns true if OptUUID was set.
func (o OptUUID) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptUUID) Reset() {
        var v uuid.UUID
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptUUID) SetTo(v uuid.UUID) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptUUID) Get() (v uuid.UUID, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptUUID) Or(d uuid.UUID) uuid.UUID {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptValidationErrorErrors returns new OptValidationErrorErrors with value set to v.
func NewOptValidationErrorErrors(v ValidationErrorErrors) OptValidationErrorErrors {
        return OptValidationErrorErrors{
                Value: v,
                Set:   true,
        }
}

// OptValidationErrorErrors is optional ValidationErrorErrors.
type OptValidationErrorErrors struct {
        Value ValidationErrorErrors
        Set   bool
}

// IsSet returns true if OptValidationErrorErrors was set.
func (o OptValidationErrorErrors) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptValidationErrorErrors) Reset() {
        var v ValidationErrorErrors
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptValidationErrorErrors) SetTo(v ValidationErrorErrors) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptValidationErrorErrors) Get() (v ValidationErrorErrors, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptValidationErrorErrors) Or(d ValidationErrorErrors) ValidationErrorErrors {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptWebhookDelivery returns new OptWebhookDelivery with value set to v.
func NewOptWebhookDelivery(v WebhookDelivery) OptWebhookDelivery {
        return OptWebhookDelivery{
                Value: v,
                Set:   true,
        }
}

// OptWebhookDelivery is optional WebhookDelivery.
type OptWebhookDelivery struct {
        Value WebhookDelivery
        Set   bool
}

// IsSet returns true if OptWebhookDelivery was set.
func (o OptWebhookDelivery) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptWebhookDelivery) Reset() {
        var v WebhookDelivery
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptWebhookDelivery) SetTo(v WebhookDelivery) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptWebhookDelivery) Get() (v WebhookDelivery, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptWebhookDelivery) Or(d WebhookDelivery) WebhookDelivery {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptWebhookResponse returns new OptWebhookResponse with value set to v.
func NewOptWebhookResponse(v WebhookResponse) OptWebhookResponse {
        return OptWebhookResponse{
                Value: v,
                Set:   true,
        }
}

// OptWebhookResponse is optional WebhookResponse.
type OptWebhookResponse struct {
        Value WebhookResponse
        Set   bool
}

// IsSet returns true if OptWebhookResponse was set.
func (o OptWebhookResponse) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptWebhookResponse) Reset() {
        var v WebhookResponse
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptWebhookResponse) SetTo(v WebhookResponse) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptWebhookResponse) Get() (v WebhookResponse, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptWebhookResponse) Or(d WebhookResponse) WebhookResponse {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// NewOptWebhookTrigger returns new OptWebhookTrigger with value set to v.
func NewOptWebhookTrigger(v WebhookTrigger) OptWebhookTrigger {
        return OptWebhookTrigger{
                Value: v,
                Set:   true,
        }
}

// OptWebhookTrigger is optional WebhookTrigger.
type OptWebhookTrigger struct {
        Value WebhookTrigger
        Set   bool
}

// IsSet returns true if OptWebhookTrigger was set.
func (o OptWebhookTrigger) IsSet() bool { return o.Set }

// Reset unsets value.
func (o *OptWebhookTrigger) Reset() {
        var v WebhookTrigger
        o.Value = v
        o.Set = false
}

// SetTo sets value to v.
func (o *OptWebhookTrigger) SetTo(v WebhookTrigger) {
        o.Set = true
        o.Value = v
}

// Get returns value and boolean that denotes whether value was set.
func (o OptWebhookTrigger) Get() (v WebhookTrigger, ok bool) {
        if !o.Set {
                return v, false
        }
        return o.Value, true
}

// Or returns value if set, or given parameter if does not.
func (o OptWebhookTrigger) Or(d WebhookTrigger) WebhookTrigger {
        if v, ok := o.Get(); ok {
                return v
        }
        return d
}

// Ref: #/components/schemas/PageLink
type PageLink struct {
        Self  OptURI `json:"self"`
        First OptURI `json:"first"`
        Next  OptURI `json:"next"`
        Prev  OptURI `json:"prev"`
        Last  OptURI `json:"last"`
}

// GetSelf returns the value of Self.
func (s *PageLink) GetSelf() OptURI {
        return s.Self
}

// GetFirst returns the value of First.
func (s *PageLink) GetFirst() OptURI {
        return s.First
}

// GetNext returns the value of Next.
func (s *PageLink) GetNext() OptURI {
        return s.Next
}

// GetPrev returns the value of Prev.
func (s *PageLink) GetPrev() OptURI {
        return s.Prev
}

// GetLast returns the value of Last.
func (s *PageLink) GetLast() OptURI {
        return s.Last
}

// SetSelf sets the value of Self.
func (s *PageLink) SetSelf(val OptURI) {
        s.Self = val
}

// SetFirst sets the value of First.
func (s *PageLink) SetFirst(val OptURI) {
        s.First = val
}

// SetNext sets the value of Next.
func (s *PageLink) SetNext(val OptURI) {
        s.Next = val
}

// SetPrev sets the value of Prev.
func (s *PageLink) SetPrev(val OptURI) {
        s.Prev = val
}

// SetLast sets the value of Last.
func (s *PageLink) SetLast(val OptURI) {
        s.Last = val
}

// Ref: #/components/schemas/PiggyBank
type PiggyBank struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // The ID of the asset account this piggy bank is connected to.
        AccountID string `json:"account_id"`
        // The name of the asset account this piggy bank is connected to.
        AccountName    OptString `json:"account_name"`
        Name           string    `json:"name"`
        CurrencyID     OptString `json:"currency_id"`
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals supported by the currency.
        CurrencyDecimalPlaces OptInt32      `json:"currency_decimal_places"`
        TargetAmount          NilString     `json:"target_amount"`
        Percentage            OptNilFloat32 `json:"percentage"`
        CurrentAmount         OptString     `json:"current_amount"`
        LeftToSave            OptNilString  `json:"left_to_save"`
        SavePerMonth          OptNilString  `json:"save_per_month"`
        // The date you started with this piggy bank.
        StartDate OptDate `json:"start_date"`
        // The date you intend to finish saving money.
        TargetDate OptNilDate   `json:"target_date"`
        Order      OptInt32     `json:"order"`
        Active     OptBool      `json:"active"`
        Notes      OptNilString `json:"notes"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The order of the group. At least 1, for the highest sorting.
        ObjectGroupOrder OptNilInt32 `json:"object_group_order"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *PiggyBank) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *PiggyBank) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetAccountID returns the value of AccountID.
func (s *PiggyBank) GetAccountID() string {
        return s.AccountID
}

// GetAccountName returns the value of AccountName.
func (s *PiggyBank) GetAccountName() OptString {
        return s.AccountName
}

// GetName returns the value of Name.
func (s *PiggyBank) GetName() string {
        return s.Name
}

// GetCurrencyID returns the value of CurrencyID.
func (s *PiggyBank) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *PiggyBank) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *PiggyBank) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *PiggyBank) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetTargetAmount returns the value of TargetAmount.
func (s *PiggyBank) GetTargetAmount() NilString {
        return s.TargetAmount
}

// GetPercentage returns the value of Percentage.
func (s *PiggyBank) GetPercentage() OptNilFloat32 {
        return s.Percentage
}

// GetCurrentAmount returns the value of CurrentAmount.
func (s *PiggyBank) GetCurrentAmount() OptString {
        return s.CurrentAmount
}

// GetLeftToSave returns the value of LeftToSave.
func (s *PiggyBank) GetLeftToSave() OptNilString {
        return s.LeftToSave
}

// GetSavePerMonth returns the value of SavePerMonth.
func (s *PiggyBank) GetSavePerMonth() OptNilString {
        return s.SavePerMonth
}

// GetStartDate returns the value of StartDate.
func (s *PiggyBank) GetStartDate() OptDate {
        return s.StartDate
}

// GetTargetDate returns the value of TargetDate.
func (s *PiggyBank) GetTargetDate() OptNilDate {
        return s.TargetDate
}

// GetOrder returns the value of Order.
func (s *PiggyBank) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *PiggyBank) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *PiggyBank) GetNotes() OptNilString {
        return s.Notes
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *PiggyBank) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupOrder returns the value of ObjectGroupOrder.
func (s *PiggyBank) GetObjectGroupOrder() OptNilInt32 {
        return s.ObjectGroupOrder
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *PiggyBank) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetCreatedAt sets the value of CreatedAt.
func (s *PiggyBank) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *PiggyBank) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetAccountID sets the value of AccountID.
func (s *PiggyBank) SetAccountID(val string) {
        s.AccountID = val
}

// SetAccountName sets the value of AccountName.
func (s *PiggyBank) SetAccountName(val OptString) {
        s.AccountName = val
}

// SetName sets the value of Name.
func (s *PiggyBank) SetName(val string) {
        s.Name = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *PiggyBank) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *PiggyBank) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *PiggyBank) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *PiggyBank) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetTargetAmount sets the value of TargetAmount.
func (s *PiggyBank) SetTargetAmount(val NilString) {
        s.TargetAmount = val
}

// SetPercentage sets the value of Percentage.
func (s *PiggyBank) SetPercentage(val OptNilFloat32) {
        s.Percentage = val
}

// SetCurrentAmount sets the value of CurrentAmount.
func (s *PiggyBank) SetCurrentAmount(val OptString) {
        s.CurrentAmount = val
}

// SetLeftToSave sets the value of LeftToSave.
func (s *PiggyBank) SetLeftToSave(val OptNilString) {
        s.LeftToSave = val
}

// SetSavePerMonth sets the value of SavePerMonth.
func (s *PiggyBank) SetSavePerMonth(val OptNilString) {
        s.SavePerMonth = val
}

// SetStartDate sets the value of StartDate.
func (s *PiggyBank) SetStartDate(val OptDate) {
        s.StartDate = val
}

// SetTargetDate sets the value of TargetDate.
func (s *PiggyBank) SetTargetDate(val OptNilDate) {
        s.TargetDate = val
}

// SetOrder sets the value of Order.
func (s *PiggyBank) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *PiggyBank) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *PiggyBank) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *PiggyBank) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupOrder sets the value of ObjectGroupOrder.
func (s *PiggyBank) SetObjectGroupOrder(val OptNilInt32) {
        s.ObjectGroupOrder = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *PiggyBank) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// Ref: #/components/schemas/PiggyBankArray
type PiggyBankArray struct {
        Data  []PiggyBankRead `json:"data"`
        Meta  Meta            `json:"meta"`
        Links PageLink        `json:"links"`
}

// GetData returns the value of Data.
func (s *PiggyBankArray) GetData() []PiggyBankRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *PiggyBankArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *PiggyBankArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *PiggyBankArray) SetData(val []PiggyBankRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *PiggyBankArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *PiggyBankArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*PiggyBankArray) listPiggyBankByAccountRes()     {}
func (*PiggyBankArray) listPiggyBankByObjectGroupRes() {}
func (*PiggyBankArray) listPiggyBankRes()              {}

// Ref: #/components/schemas/PiggyBankEvent
type PiggyBankEvent struct {
        CreatedAt             OptDateTime `json:"created_at"`
        UpdatedAt             OptDateTime `json:"updated_at"`
        CurrencyID            OptString   `json:"currency_id"`
        CurrencyCode          OptString   `json:"currency_code"`
        CurrencySymbol        OptString   `json:"currency_symbol"`
        CurrencyDecimalPlaces OptInt32    `json:"currency_decimal_places"`
        Amount                OptString   `json:"amount"`
        // The journal associated with the event.
        TransactionJournalID OptString `json:"transaction_journal_id"`
        // The transaction group associated with the event.
        TransactionGroupID OptString `json:"transaction_group_id"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *PiggyBankEvent) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *PiggyBankEvent) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetCurrencyID returns the value of CurrencyID.
func (s *PiggyBankEvent) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *PiggyBankEvent) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *PiggyBankEvent) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *PiggyBankEvent) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetAmount returns the value of Amount.
func (s *PiggyBankEvent) GetAmount() OptString {
        return s.Amount
}

// GetTransactionJournalID returns the value of TransactionJournalID.
func (s *PiggyBankEvent) GetTransactionJournalID() OptString {
        return s.TransactionJournalID
}

// GetTransactionGroupID returns the value of TransactionGroupID.
func (s *PiggyBankEvent) GetTransactionGroupID() OptString {
        return s.TransactionGroupID
}

// SetCreatedAt sets the value of CreatedAt.
func (s *PiggyBankEvent) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *PiggyBankEvent) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *PiggyBankEvent) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *PiggyBankEvent) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *PiggyBankEvent) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *PiggyBankEvent) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetAmount sets the value of Amount.
func (s *PiggyBankEvent) SetAmount(val OptString) {
        s.Amount = val
}

// SetTransactionJournalID sets the value of TransactionJournalID.
func (s *PiggyBankEvent) SetTransactionJournalID(val OptString) {
        s.TransactionJournalID = val
}

// SetTransactionGroupID sets the value of TransactionGroupID.
func (s *PiggyBankEvent) SetTransactionGroupID(val OptString) {
        s.TransactionGroupID = val
}

// Ref: #/components/schemas/PiggyBankEventArray
type PiggyBankEventArray struct {
        Data  []PiggyBankEventRead `json:"data"`
        Meta  Meta                 `json:"meta"`
        Links PageLink             `json:"links"`
}

// GetData returns the value of Data.
func (s *PiggyBankEventArray) GetData() []PiggyBankEventRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *PiggyBankEventArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *PiggyBankEventArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *PiggyBankEventArray) SetData(val []PiggyBankEventRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *PiggyBankEventArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *PiggyBankEventArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*PiggyBankEventArray) listEventByPiggyBankRes()   {}
func (*PiggyBankEventArray) listEventByTransactionRes() {}

// Ref: #/components/schemas/PiggyBankEventRead
type PiggyBankEventRead struct {
        // Immutable value.
        Type       string         `json:"type"`
        ID         string         `json:"id"`
        Attributes PiggyBankEvent `json:"attributes"`
        Links      ObjectLink     `json:"links"`
}

// GetType returns the value of Type.
func (s *PiggyBankEventRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *PiggyBankEventRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *PiggyBankEventRead) GetAttributes() PiggyBankEvent {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *PiggyBankEventRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *PiggyBankEventRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *PiggyBankEventRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *PiggyBankEventRead) SetAttributes(val PiggyBankEvent) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *PiggyBankEventRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/PiggyBankRead
type PiggyBankRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes PiggyBank  `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *PiggyBankRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *PiggyBankRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *PiggyBankRead) GetAttributes() PiggyBank {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *PiggyBankRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *PiggyBankRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *PiggyBankRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *PiggyBankRead) SetAttributes(val PiggyBank) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *PiggyBankRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/PiggyBankSingle
type PiggyBankSingle struct {
        Data PiggyBankRead `json:"data"`
}

// GetData returns the value of Data.
func (s *PiggyBankSingle) GetData() PiggyBankRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *PiggyBankSingle) SetData(val PiggyBankRead) {
        s.Data = val
}

func (*PiggyBankSingle) getPiggyBankRes()    {}
func (*PiggyBankSingle) storePiggyBankRes()  {}
func (*PiggyBankSingle) updatePiggyBankRes() {}

// Ref: #/components/schemas/PiggyBankStore
type PiggyBankStore struct {
        Name string `json:"name"`
        // The ID of the asset account this piggy bank is connected to.
        AccountID     string    `json:"account_id"`
        TargetAmount  NilString `json:"target_amount"`
        CurrentAmount OptString `json:"current_amount"`
        // The date you started with this piggy bank.
        StartDate OptDate `json:"start_date"`
        // The date you intend to finish saving money.
        TargetDate OptNilDate   `json:"target_date"`
        Order      OptInt32     `json:"order"`
        Active     OptBool      `json:"active"`
        Notes      OptNilString `json:"notes"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetName returns the value of Name.
func (s *PiggyBankStore) GetName() string {
        return s.Name
}

// GetAccountID returns the value of AccountID.
func (s *PiggyBankStore) GetAccountID() string {
        return s.AccountID
}

// GetTargetAmount returns the value of TargetAmount.
func (s *PiggyBankStore) GetTargetAmount() NilString {
        return s.TargetAmount
}

// GetCurrentAmount returns the value of CurrentAmount.
func (s *PiggyBankStore) GetCurrentAmount() OptString {
        return s.CurrentAmount
}

// GetStartDate returns the value of StartDate.
func (s *PiggyBankStore) GetStartDate() OptDate {
        return s.StartDate
}

// GetTargetDate returns the value of TargetDate.
func (s *PiggyBankStore) GetTargetDate() OptNilDate {
        return s.TargetDate
}

// GetOrder returns the value of Order.
func (s *PiggyBankStore) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *PiggyBankStore) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *PiggyBankStore) GetNotes() OptNilString {
        return s.Notes
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *PiggyBankStore) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *PiggyBankStore) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetName sets the value of Name.
func (s *PiggyBankStore) SetName(val string) {
        s.Name = val
}

// SetAccountID sets the value of AccountID.
func (s *PiggyBankStore) SetAccountID(val string) {
        s.AccountID = val
}

// SetTargetAmount sets the value of TargetAmount.
func (s *PiggyBankStore) SetTargetAmount(val NilString) {
        s.TargetAmount = val
}

// SetCurrentAmount sets the value of CurrentAmount.
func (s *PiggyBankStore) SetCurrentAmount(val OptString) {
        s.CurrentAmount = val
}

// SetStartDate sets the value of StartDate.
func (s *PiggyBankStore) SetStartDate(val OptDate) {
        s.StartDate = val
}

// SetTargetDate sets the value of TargetDate.
func (s *PiggyBankStore) SetTargetDate(val OptNilDate) {
        s.TargetDate = val
}

// SetOrder sets the value of Order.
func (s *PiggyBankStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *PiggyBankStore) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *PiggyBankStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *PiggyBankStore) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *PiggyBankStore) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// Ref: #/components/schemas/PiggyBankUpdate
type PiggyBankUpdate struct {
        Name OptString `json:"name"`
        // The ID of the asset account this piggy bank is connected to.
        AccountID     OptString    `json:"account_id"`
        CurrencyID    OptString    `json:"currency_id"`
        CurrencyCode  OptString    `json:"currency_code"`
        TargetAmount  OptNilString `json:"target_amount"`
        CurrentAmount OptString    `json:"current_amount"`
        // The date you started with this piggy bank.
        StartDate OptDate `json:"start_date"`
        // The date you intend to finish saving money.
        TargetDate OptNilDate   `json:"target_date"`
        Order      OptInt32     `json:"order"`
        Active     OptBool      `json:"active"`
        Notes      OptNilString `json:"notes"`
        // The group ID of the group this object is part of. NULL if no group.
        ObjectGroupID OptNilString `json:"object_group_id"`
        // The name of the group. NULL if no group.
        ObjectGroupTitle OptNilString `json:"object_group_title"`
}

// GetName returns the value of Name.
func (s *PiggyBankUpdate) GetName() OptString {
        return s.Name
}

// GetAccountID returns the value of AccountID.
func (s *PiggyBankUpdate) GetAccountID() OptString {
        return s.AccountID
}

// GetCurrencyID returns the value of CurrencyID.
func (s *PiggyBankUpdate) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *PiggyBankUpdate) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetTargetAmount returns the value of TargetAmount.
func (s *PiggyBankUpdate) GetTargetAmount() OptNilString {
        return s.TargetAmount
}

// GetCurrentAmount returns the value of CurrentAmount.
func (s *PiggyBankUpdate) GetCurrentAmount() OptString {
        return s.CurrentAmount
}

// GetStartDate returns the value of StartDate.
func (s *PiggyBankUpdate) GetStartDate() OptDate {
        return s.StartDate
}

// GetTargetDate returns the value of TargetDate.
func (s *PiggyBankUpdate) GetTargetDate() OptNilDate {
        return s.TargetDate
}

// GetOrder returns the value of Order.
func (s *PiggyBankUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *PiggyBankUpdate) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *PiggyBankUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetObjectGroupID returns the value of ObjectGroupID.
func (s *PiggyBankUpdate) GetObjectGroupID() OptNilString {
        return s.ObjectGroupID
}

// GetObjectGroupTitle returns the value of ObjectGroupTitle.
func (s *PiggyBankUpdate) GetObjectGroupTitle() OptNilString {
        return s.ObjectGroupTitle
}

// SetName sets the value of Name.
func (s *PiggyBankUpdate) SetName(val OptString) {
        s.Name = val
}

// SetAccountID sets the value of AccountID.
func (s *PiggyBankUpdate) SetAccountID(val OptString) {
        s.AccountID = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *PiggyBankUpdate) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *PiggyBankUpdate) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetTargetAmount sets the value of TargetAmount.
func (s *PiggyBankUpdate) SetTargetAmount(val OptNilString) {
        s.TargetAmount = val
}

// SetCurrentAmount sets the value of CurrentAmount.
func (s *PiggyBankUpdate) SetCurrentAmount(val OptString) {
        s.CurrentAmount = val
}

// SetStartDate sets the value of StartDate.
func (s *PiggyBankUpdate) SetStartDate(val OptDate) {
        s.StartDate = val
}

// SetTargetDate sets the value of TargetDate.
func (s *PiggyBankUpdate) SetTargetDate(val OptNilDate) {
        s.TargetDate = val
}

// SetOrder sets the value of Order.
func (s *PiggyBankUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *PiggyBankUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *PiggyBankUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetObjectGroupID sets the value of ObjectGroupID.
func (s *PiggyBankUpdate) SetObjectGroupID(val OptNilString) {
        s.ObjectGroupID = val
}

// SetObjectGroupTitle sets the value of ObjectGroupTitle.
func (s *PiggyBankUpdate) SetObjectGroupTitle(val OptNilString) {
        s.ObjectGroupTitle = val
}

// Ref: #/components/schemas/PolymorphicProperty
// PolymorphicProperty represents sum type.
type PolymorphicProperty struct {
        Type                 PolymorphicPropertyType // switch on this field
        Bool                 bool
        String               string
        PolymorphicProperty2 PolymorphicProperty2
        StringArrayItemArray []StringArrayItem
}

// PolymorphicPropertyType is oneOf type of PolymorphicProperty.
type PolymorphicPropertyType string

// Possible values for PolymorphicPropertyType.
const (
        BoolPolymorphicProperty                 PolymorphicPropertyType = "bool"
        StringPolymorphicProperty               PolymorphicPropertyType = "string"
        PolymorphicProperty2PolymorphicProperty PolymorphicPropertyType = "PolymorphicProperty2"
        StringArrayItemArrayPolymorphicProperty PolymorphicPropertyType = "[]StringArrayItem"
)

// IsBool reports whether PolymorphicProperty is bool.
func (s PolymorphicProperty) IsBool() bool { return s.Type == BoolPolymorphicProperty }

// IsString reports whether PolymorphicProperty is string.
func (s PolymorphicProperty) IsString() bool { return s.Type == StringPolymorphicProperty }

// IsPolymorphicProperty2 reports whether PolymorphicProperty is PolymorphicProperty2.
func (s PolymorphicProperty) IsPolymorphicProperty2() bool {
        return s.Type == PolymorphicProperty2PolymorphicProperty
}

// IsStringArrayItemArray reports whether PolymorphicProperty is []StringArrayItem.
func (s PolymorphicProperty) IsStringArrayItemArray() bool {
        return s.Type == StringArrayItemArrayPolymorphicProperty
}

// SetBool sets PolymorphicProperty to bool.
func (s *PolymorphicProperty) SetBool(v bool) {
        s.Type = BoolPolymorphicProperty
        s.Bool = v
}

// GetBool returns bool and true boolean if PolymorphicProperty is bool.
func (s PolymorphicProperty) GetBool() (v bool, ok bool) {
        if !s.IsBool() {
                return v, false
        }
        return s.Bool, true
}

// NewBoolPolymorphicProperty returns new PolymorphicProperty from bool.
func NewBoolPolymorphicProperty(v bool) PolymorphicProperty {
        var s PolymorphicProperty
        s.SetBool(v)
        return s
}

// SetString sets PolymorphicProperty to string.
func (s *PolymorphicProperty) SetString(v string) {
        s.Type = StringPolymorphicProperty
        s.String = v
}

// GetString returns string and true boolean if PolymorphicProperty is string.
func (s PolymorphicProperty) GetString() (v string, ok bool) {
        if !s.IsString() {
                return v, false
        }
        return s.String, true
}

// NewStringPolymorphicProperty returns new PolymorphicProperty from string.
func NewStringPolymorphicProperty(v string) PolymorphicProperty {
        var s PolymorphicProperty
        s.SetString(v)
        return s
}

// SetPolymorphicProperty2 sets PolymorphicProperty to PolymorphicProperty2.
func (s *PolymorphicProperty) SetPolymorphicProperty2(v PolymorphicProperty2) {
        s.Type = PolymorphicProperty2PolymorphicProperty
        s.PolymorphicProperty2 = v
}

// GetPolymorphicProperty2 returns PolymorphicProperty2 and true boolean if PolymorphicProperty is PolymorphicProperty2.
func (s PolymorphicProperty) GetPolymorphicProperty2() (v PolymorphicProperty2, ok bool) {
        if !s.IsPolymorphicProperty2() {
                return v, false
        }
        return s.PolymorphicProperty2, true
}

// NewPolymorphicProperty2PolymorphicProperty returns new PolymorphicProperty from PolymorphicProperty2.
func NewPolymorphicProperty2PolymorphicProperty(v PolymorphicProperty2) PolymorphicProperty {
        var s PolymorphicProperty
        s.SetPolymorphicProperty2(v)
        return s
}

// SetStringArrayItemArray sets PolymorphicProperty to []StringArrayItem.
func (s *PolymorphicProperty) SetStringArrayItemArray(v []StringArrayItem) {
        s.Type = StringArrayItemArrayPolymorphicProperty
        s.StringArrayItemArray = v
}

// GetStringArrayItemArray returns []StringArrayItem and true boolean if PolymorphicProperty is []StringArrayItem.
func (s PolymorphicProperty) GetStringArrayItemArray() (v []StringArrayItem, ok bool) {
        if !s.IsStringArrayItemArray() {
                return v, false
        }
        return s.StringArrayItemArray, true
}

// NewStringArrayItemArrayPolymorphicProperty returns new PolymorphicProperty from []StringArrayItem.
func NewStringArrayItemArrayPolymorphicProperty(v []StringArrayItem) PolymorphicProperty {
        var s PolymorphicProperty
        s.SetStringArrayItemArray(v)
        return s
}

type PolymorphicProperty2 struct{}

// Ref: #/components/schemas/Preference
type Preference struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        Name      string      `json:"name"`
        // The actual preference content.
        Data PolymorphicProperty `json:"data"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Preference) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Preference) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetName returns the value of Name.
func (s *Preference) GetName() string {
        return s.Name
}

// GetData returns the value of Data.
func (s *Preference) GetData() PolymorphicProperty {
        return s.Data
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Preference) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Preference) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetName sets the value of Name.
func (s *Preference) SetName(val string) {
        s.Name = val
}

// SetData sets the value of Data.
func (s *Preference) SetData(val PolymorphicProperty) {
        s.Data = val
}

// Ref: #/components/schemas/PreferenceArray
type PreferenceArray struct {
        Data  []PreferenceRead `json:"data"`
        Meta  Meta             `json:"meta"`
        Links PageLink         `json:"links"`
}

// GetData returns the value of Data.
func (s *PreferenceArray) GetData() []PreferenceRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *PreferenceArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *PreferenceArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *PreferenceArray) SetData(val []PreferenceRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *PreferenceArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *PreferenceArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*PreferenceArray) listPreferenceRes() {}

// Ref: #/components/schemas/PreferenceRead
type PreferenceRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes Preference `json:"attributes"`
}

// GetType returns the value of Type.
func (s *PreferenceRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *PreferenceRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *PreferenceRead) GetAttributes() Preference {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *PreferenceRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *PreferenceRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *PreferenceRead) SetAttributes(val Preference) {
        s.Attributes = val
}

// Ref: #/components/schemas/PreferenceSingle
type PreferenceSingle struct {
        Data PreferenceRead `json:"data"`
}

// GetData returns the value of Data.
func (s *PreferenceSingle) GetData() PreferenceRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *PreferenceSingle) SetData(val PreferenceRead) {
        s.Data = val
}

func (*PreferenceSingle) getPreferenceRes()    {}
func (*PreferenceSingle) storePreferenceRes()  {}
func (*PreferenceSingle) updatePreferenceRes() {}

// Ref: #/components/schemas/PreferenceUpdate
type PreferenceUpdate struct {
        // The actual preference content.
        Data PolymorphicProperty `json:"data"`
}

// GetData returns the value of Data.
func (s *PreferenceUpdate) GetData() PolymorphicProperty {
        return s.Data
}

// SetData sets the value of Data.
func (s *PreferenceUpdate) SetData(val PolymorphicProperty) {
        s.Data = val
}

// PurgeDataNoContent is response for PurgeData operation.
type PurgeDataNoContent struct{}

func (*PurgeDataNoContent) purgeDataRes() {}

// Ref: #/components/schemas/Recurrence
type Recurrence struct {
        CreatedAt OptDateTime                  `json:"created_at"`
        UpdatedAt OptDateTime                  `json:"updated_at"`
        Type      OptRecurrenceTransactionType `json:"type"`
        Title     OptString                    `json:"title"`
        // Not to be confused with the description of the actual transaction(s) being created.
        Description OptString `json:"description"`
        // First time the recurring transaction will fire. Must be after today.
        FirstDate OptDate `json:"first_date"`
        // Last time the recurring transaction has fired.
        LatestDate OptNilDate `json:"latest_date"`
        // Date until the recurring transaction can fire. Use either this field or repetitions.
        RepeatUntil OptNilDate `json:"repeat_until"`
        // Max number of created transactions. Use either this field or repeat_until.
        NrOfRepetitions OptNilInt32 `json:"nr_of_repetitions"`
        // Whether or not to fire the rules after the creation of a transaction.
        ApplyRules OptBool `json:"apply_rules"`
        // If the recurrence is even active.
        Active       OptBool                 `json:"active"`
        Notes        OptNilString            `json:"notes"`
        Repetitions  []RecurrenceRepetition  `json:"repetitions"`
        Transactions []RecurrenceTransaction `json:"transactions"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Recurrence) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Recurrence) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetType returns the value of Type.
func (s *Recurrence) GetType() OptRecurrenceTransactionType {
        return s.Type
}

// GetTitle returns the value of Title.
func (s *Recurrence) GetTitle() OptString {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *Recurrence) GetDescription() OptString {
        return s.Description
}

// GetFirstDate returns the value of FirstDate.
func (s *Recurrence) GetFirstDate() OptDate {
        return s.FirstDate
}

// GetLatestDate returns the value of LatestDate.
func (s *Recurrence) GetLatestDate() OptNilDate {
        return s.LatestDate
}

// GetRepeatUntil returns the value of RepeatUntil.
func (s *Recurrence) GetRepeatUntil() OptNilDate {
        return s.RepeatUntil
}

// GetNrOfRepetitions returns the value of NrOfRepetitions.
func (s *Recurrence) GetNrOfRepetitions() OptNilInt32 {
        return s.NrOfRepetitions
}

// GetApplyRules returns the value of ApplyRules.
func (s *Recurrence) GetApplyRules() OptBool {
        return s.ApplyRules
}

// GetActive returns the value of Active.
func (s *Recurrence) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *Recurrence) GetNotes() OptNilString {
        return s.Notes
}

// GetRepetitions returns the value of Repetitions.
func (s *Recurrence) GetRepetitions() []RecurrenceRepetition {
        return s.Repetitions
}

// GetTransactions returns the value of Transactions.
func (s *Recurrence) GetTransactions() []RecurrenceTransaction {
        return s.Transactions
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Recurrence) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Recurrence) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetType sets the value of Type.
func (s *Recurrence) SetType(val OptRecurrenceTransactionType) {
        s.Type = val
}

// SetTitle sets the value of Title.
func (s *Recurrence) SetTitle(val OptString) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *Recurrence) SetDescription(val OptString) {
        s.Description = val
}

// SetFirstDate sets the value of FirstDate.
func (s *Recurrence) SetFirstDate(val OptDate) {
        s.FirstDate = val
}

// SetLatestDate sets the value of LatestDate.
func (s *Recurrence) SetLatestDate(val OptNilDate) {
        s.LatestDate = val
}

// SetRepeatUntil sets the value of RepeatUntil.
func (s *Recurrence) SetRepeatUntil(val OptNilDate) {
        s.RepeatUntil = val
}

// SetNrOfRepetitions sets the value of NrOfRepetitions.
func (s *Recurrence) SetNrOfRepetitions(val OptNilInt32) {
        s.NrOfRepetitions = val
}

// SetApplyRules sets the value of ApplyRules.
func (s *Recurrence) SetApplyRules(val OptBool) {
        s.ApplyRules = val
}

// SetActive sets the value of Active.
func (s *Recurrence) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *Recurrence) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetRepetitions sets the value of Repetitions.
func (s *Recurrence) SetRepetitions(val []RecurrenceRepetition) {
        s.Repetitions = val
}

// SetTransactions sets the value of Transactions.
func (s *Recurrence) SetTransactions(val []RecurrenceTransaction) {
        s.Transactions = val
}

// Ref: #/components/schemas/RecurrenceArray
type RecurrenceArray struct {
        Data  []RecurrenceRead `json:"data"`
        Meta  Meta             `json:"meta"`
        Links PageLink         `json:"links"`
}

// GetData returns the value of Data.
func (s *RecurrenceArray) GetData() []RecurrenceRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *RecurrenceArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *RecurrenceArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *RecurrenceArray) SetData(val []RecurrenceRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *RecurrenceArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *RecurrenceArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*RecurrenceArray) listRecurrenceByCurrencyRes() {}
func (*RecurrenceArray) listRecurrenceRes()           {}

// Ref: #/components/schemas/RecurrenceRead
type RecurrenceRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes Recurrence `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *RecurrenceRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *RecurrenceRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *RecurrenceRead) GetAttributes() Recurrence {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *RecurrenceRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *RecurrenceRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *RecurrenceRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *RecurrenceRead) SetAttributes(val Recurrence) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *RecurrenceRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/RecurrenceRepetition
type RecurrenceRepetition struct {
        ID        OptString                `json:"id"`
        CreatedAt OptDateTime              `json:"created_at"`
        UpdatedAt OptDateTime              `json:"updated_at"`
        Type      RecurrenceRepetitionType `json:"type"`
        // Information that defined the type of repetition.
        // - For 'daily', this is empty.
        // - For 'weekly', it is day of the week between 1 and 7 (Monday - Sunday).
        // - For 'ndom', it is '1,2' or '4,5' or something else, where the first number is the week in the
        // month, and the second number is the day in the week (between 1 and 7). '2,3' means: the 2nd
        // Wednesday of the month
        // - For 'monthly' it is the day of the month (1 - 31)
        // - For yearly, it is a full date, ie '2018-09-17'. The year you use does not matter.
        Moment string `json:"moment"`
        // How many occurrences to skip. 0 means skip nothing. 1 means every other.
        Skip OptInt32 `json:"skip"`
        // How to respond when the recurring transaction falls in the weekend. Possible values:
        // 1. Do nothing, just create it
        // 2. Create no transaction.
        // 3. Skip to the previous Friday.
        // 4. Skip to the next Monday.
        Weekend OptInt32 `json:"weekend"`
        // Auto-generated repetition description.
        Description OptString `json:"description"`
        // Array of future dates when the repetition will apply to. Auto generated.
        Occurrences []time.Time `json:"occurrences"`
}

// GetID returns the value of ID.
func (s *RecurrenceRepetition) GetID() OptString {
        return s.ID
}

// GetCreatedAt returns the value of CreatedAt.
func (s *RecurrenceRepetition) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *RecurrenceRepetition) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetType returns the value of Type.
func (s *RecurrenceRepetition) GetType() RecurrenceRepetitionType {
        return s.Type
}

// GetMoment returns the value of Moment.
func (s *RecurrenceRepetition) GetMoment() string {
        return s.Moment
}

// GetSkip returns the value of Skip.
func (s *RecurrenceRepetition) GetSkip() OptInt32 {
        return s.Skip
}

// GetWeekend returns the value of Weekend.
func (s *RecurrenceRepetition) GetWeekend() OptInt32 {
        return s.Weekend
}

// GetDescription returns the value of Description.
func (s *RecurrenceRepetition) GetDescription() OptString {
        return s.Description
}

// GetOccurrences returns the value of Occurrences.
func (s *RecurrenceRepetition) GetOccurrences() []time.Time {
        return s.Occurrences
}

// SetID sets the value of ID.
func (s *RecurrenceRepetition) SetID(val OptString) {
        s.ID = val
}

// SetCreatedAt sets the value of CreatedAt.
func (s *RecurrenceRepetition) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *RecurrenceRepetition) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetType sets the value of Type.
func (s *RecurrenceRepetition) SetType(val RecurrenceRepetitionType) {
        s.Type = val
}

// SetMoment sets the value of Moment.
func (s *RecurrenceRepetition) SetMoment(val string) {
        s.Moment = val
}

// SetSkip sets the value of Skip.
func (s *RecurrenceRepetition) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetWeekend sets the value of Weekend.
func (s *RecurrenceRepetition) SetWeekend(val OptInt32) {
        s.Weekend = val
}

// SetDescription sets the value of Description.
func (s *RecurrenceRepetition) SetDescription(val OptString) {
        s.Description = val
}

// SetOccurrences sets the value of Occurrences.
func (s *RecurrenceRepetition) SetOccurrences(val []time.Time) {
        s.Occurrences = val
}

// Ref: #/components/schemas/RecurrenceRepetitionStore
type RecurrenceRepetitionStore struct {
        Type RecurrenceRepetitionType `json:"type"`
        // Information that defined the type of repetition.
        // - For 'daily', this is empty.
        // - For 'weekly', it is day of the week between 1 and 7 (Monday - Sunday).
        // - For 'ndom', it is '1,2' or '4,5' or something else, where the first number is the week in the
        // month, and the second number is the day in the week (between 1 and 7). '2,3' means: the 2nd
        // Wednesday of the month
        // - For 'monthly' it is the day of the month (1 - 31)
        // - For yearly, it is a full date, ie '2018-09-17'. The year you use does not matter.
        Moment string `json:"moment"`
        // How many occurrences to skip. 0 means skip nothing. 1 means every other.
        Skip OptInt32 `json:"skip"`
        // How to respond when the recurring transaction falls in the weekend. Possible values:
        // 1. Do nothing, just create it
        // 2. Create no transaction.
        // 3. Skip to the previous Friday.
        // 4. Skip to the next Monday.
        Weekend OptInt32 `json:"weekend"`
}

// GetType returns the value of Type.
func (s *RecurrenceRepetitionStore) GetType() RecurrenceRepetitionType {
        return s.Type
}

// GetMoment returns the value of Moment.
func (s *RecurrenceRepetitionStore) GetMoment() string {
        return s.Moment
}

// GetSkip returns the value of Skip.
func (s *RecurrenceRepetitionStore) GetSkip() OptInt32 {
        return s.Skip
}

// GetWeekend returns the value of Weekend.
func (s *RecurrenceRepetitionStore) GetWeekend() OptInt32 {
        return s.Weekend
}

// SetType sets the value of Type.
func (s *RecurrenceRepetitionStore) SetType(val RecurrenceRepetitionType) {
        s.Type = val
}

// SetMoment sets the value of Moment.
func (s *RecurrenceRepetitionStore) SetMoment(val string) {
        s.Moment = val
}

// SetSkip sets the value of Skip.
func (s *RecurrenceRepetitionStore) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetWeekend sets the value of Weekend.
func (s *RecurrenceRepetitionStore) SetWeekend(val OptInt32) {
        s.Weekend = val
}

// The type of the repetition. ndom means: the n-th weekday of the month, where you can also specify
// which day of the week.
// Ref: #/components/schemas/RecurrenceRepetitionType
type RecurrenceRepetitionType string

const (
        RecurrenceRepetitionTypeDaily   RecurrenceRepetitionType = "daily"
        RecurrenceRepetitionTypeWeekly  RecurrenceRepetitionType = "weekly"
        RecurrenceRepetitionTypeNdom    RecurrenceRepetitionType = "ndom"
        RecurrenceRepetitionTypeMonthly RecurrenceRepetitionType = "monthly"
        RecurrenceRepetitionTypeYearly  RecurrenceRepetitionType = "yearly"
)

// AllValues returns all RecurrenceRepetitionType values.
func (RecurrenceRepetitionType) AllValues() []RecurrenceRepetitionType {
        return []RecurrenceRepetitionType{
                RecurrenceRepetitionTypeDaily,
                RecurrenceRepetitionTypeWeekly,
                RecurrenceRepetitionTypeNdom,
                RecurrenceRepetitionTypeMonthly,
                RecurrenceRepetitionTypeYearly,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s RecurrenceRepetitionType) MarshalText() ([]byte, error) {
        switch s {
        case RecurrenceRepetitionTypeDaily:
                return []byte(s), nil
        case RecurrenceRepetitionTypeWeekly:
                return []byte(s), nil
        case RecurrenceRepetitionTypeNdom:
                return []byte(s), nil
        case RecurrenceRepetitionTypeMonthly:
                return []byte(s), nil
        case RecurrenceRepetitionTypeYearly:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *RecurrenceRepetitionType) UnmarshalText(data []byte) error {
        switch RecurrenceRepetitionType(data) {
        case RecurrenceRepetitionTypeDaily:
                *s = RecurrenceRepetitionTypeDaily
                return nil
        case RecurrenceRepetitionTypeWeekly:
                *s = RecurrenceRepetitionTypeWeekly
                return nil
        case RecurrenceRepetitionTypeNdom:
                *s = RecurrenceRepetitionTypeNdom
                return nil
        case RecurrenceRepetitionTypeMonthly:
                *s = RecurrenceRepetitionTypeMonthly
                return nil
        case RecurrenceRepetitionTypeYearly:
                *s = RecurrenceRepetitionTypeYearly
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/RecurrenceRepetitionUpdate
type RecurrenceRepetitionUpdate struct {
        Type OptRecurrenceRepetitionType `json:"type"`
        // Information that defined the type of repetition.
        // - For 'daily', this is empty.
        // - For 'weekly', it is day of the week between 1 and 7 (Monday - Sunday).
        // - For 'ndom', it is '1,2' or '4,5' or something else, where the first number is the week in the
        // month, and the second number is the day in the week (between 1 and 7). '2,3' means: the 2nd
        // Wednesday of the month
        // - For 'monthly' it is the day of the month (1 - 31)
        // - For yearly, it is a full date, ie '2018-09-17'. The year you use does not matter.
        Moment OptString `json:"moment"`
        // How many occurrences to skip. 0 means skip nothing. 1 means every other.
        Skip OptInt32 `json:"skip"`
        // How to respond when the recurring transaction falls in the weekend. Possible values:
        // 1. Do nothing, just create it
        // 2. Create no transaction.
        // 3. Skip to the previous Friday.
        // 4. Skip to the next Monday.
        Weekend OptInt32 `json:"weekend"`
}

// GetType returns the value of Type.
func (s *RecurrenceRepetitionUpdate) GetType() OptRecurrenceRepetitionType {
        return s.Type
}

// GetMoment returns the value of Moment.
func (s *RecurrenceRepetitionUpdate) GetMoment() OptString {
        return s.Moment
}

// GetSkip returns the value of Skip.
func (s *RecurrenceRepetitionUpdate) GetSkip() OptInt32 {
        return s.Skip
}

// GetWeekend returns the value of Weekend.
func (s *RecurrenceRepetitionUpdate) GetWeekend() OptInt32 {
        return s.Weekend
}

// SetType sets the value of Type.
func (s *RecurrenceRepetitionUpdate) SetType(val OptRecurrenceRepetitionType) {
        s.Type = val
}

// SetMoment sets the value of Moment.
func (s *RecurrenceRepetitionUpdate) SetMoment(val OptString) {
        s.Moment = val
}

// SetSkip sets the value of Skip.
func (s *RecurrenceRepetitionUpdate) SetSkip(val OptInt32) {
        s.Skip = val
}

// SetWeekend sets the value of Weekend.
func (s *RecurrenceRepetitionUpdate) SetWeekend(val OptInt32) {
        s.Weekend = val
}

// Ref: #/components/schemas/RecurrenceSingle
type RecurrenceSingle struct {
        Data RecurrenceRead `json:"data"`
}

// GetData returns the value of Data.
func (s *RecurrenceSingle) GetData() RecurrenceRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *RecurrenceSingle) SetData(val RecurrenceRead) {
        s.Data = val
}

func (*RecurrenceSingle) getRecurrenceRes()    {}
func (*RecurrenceSingle) storeRecurrenceRes()  {}
func (*RecurrenceSingle) updateRecurrenceRes() {}

// Ref: #/components/schemas/RecurrenceStore
type RecurrenceStore struct {
        Type  RecurrenceTransactionType `json:"type"`
        Title string                    `json:"title"`
        // Not to be confused with the description of the actual transaction(s) being created.
        Description OptString `json:"description"`
        // First time the recurring transaction will fire. Must be after today.
        FirstDate time.Time `json:"first_date"`
        // Date until the recurring transaction can fire. Use either this field or repetitions.
        RepeatUntil NilDate `json:"repeat_until"`
        // Max number of created transactions. Use either this field or repeat_until.
        NrOfRepetitions OptNilInt32 `json:"nr_of_repetitions"`
        // Whether or not to fire the rules after the creation of a transaction.
        ApplyRules OptBool `json:"apply_rules"`
        // If the recurrence is even active.
        Active       OptBool                      `json:"active"`
        Notes        OptNilString                 `json:"notes"`
        Repetitions  []RecurrenceRepetitionStore  `json:"repetitions"`
        Transactions []RecurrenceTransactionStore `json:"transactions"`
}

// GetType returns the value of Type.
func (s *RecurrenceStore) GetType() RecurrenceTransactionType {
        return s.Type
}

// GetTitle returns the value of Title.
func (s *RecurrenceStore) GetTitle() string {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RecurrenceStore) GetDescription() OptString {
        return s.Description
}

// GetFirstDate returns the value of FirstDate.
func (s *RecurrenceStore) GetFirstDate() time.Time {
        return s.FirstDate
}

// GetRepeatUntil returns the value of RepeatUntil.
func (s *RecurrenceStore) GetRepeatUntil() NilDate {
        return s.RepeatUntil
}

// GetNrOfRepetitions returns the value of NrOfRepetitions.
func (s *RecurrenceStore) GetNrOfRepetitions() OptNilInt32 {
        return s.NrOfRepetitions
}

// GetApplyRules returns the value of ApplyRules.
func (s *RecurrenceStore) GetApplyRules() OptBool {
        return s.ApplyRules
}

// GetActive returns the value of Active.
func (s *RecurrenceStore) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *RecurrenceStore) GetNotes() OptNilString {
        return s.Notes
}

// GetRepetitions returns the value of Repetitions.
func (s *RecurrenceStore) GetRepetitions() []RecurrenceRepetitionStore {
        return s.Repetitions
}

// GetTransactions returns the value of Transactions.
func (s *RecurrenceStore) GetTransactions() []RecurrenceTransactionStore {
        return s.Transactions
}

// SetType sets the value of Type.
func (s *RecurrenceStore) SetType(val RecurrenceTransactionType) {
        s.Type = val
}

// SetTitle sets the value of Title.
func (s *RecurrenceStore) SetTitle(val string) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RecurrenceStore) SetDescription(val OptString) {
        s.Description = val
}

// SetFirstDate sets the value of FirstDate.
func (s *RecurrenceStore) SetFirstDate(val time.Time) {
        s.FirstDate = val
}

// SetRepeatUntil sets the value of RepeatUntil.
func (s *RecurrenceStore) SetRepeatUntil(val NilDate) {
        s.RepeatUntil = val
}

// SetNrOfRepetitions sets the value of NrOfRepetitions.
func (s *RecurrenceStore) SetNrOfRepetitions(val OptNilInt32) {
        s.NrOfRepetitions = val
}

// SetApplyRules sets the value of ApplyRules.
func (s *RecurrenceStore) SetApplyRules(val OptBool) {
        s.ApplyRules = val
}

// SetActive sets the value of Active.
func (s *RecurrenceStore) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *RecurrenceStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetRepetitions sets the value of Repetitions.
func (s *RecurrenceStore) SetRepetitions(val []RecurrenceRepetitionStore) {
        s.Repetitions = val
}

// SetTransactions sets the value of Transactions.
func (s *RecurrenceStore) SetTransactions(val []RecurrenceTransactionStore) {
        s.Transactions = val
}

// Ref: #/components/schemas/RecurrenceTransaction
type RecurrenceTransaction struct {
        ID          OptString `json:"id"`
        Description string    `json:"description"`
        // Amount of the transaction.
        Amount string `json:"amount"`
        // Foreign amount of the transaction.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Submit either a currency_id or a currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Submit either a currency_id or a currency_code.
        CurrencyCode   OptString `json:"currency_code"`
        CurrencySymbol OptString `json:"currency_symbol"`
        // Number of decimals in the currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // Submit either a foreign_currency_id or a foreign_currency_code, or neither.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // Submit either a foreign_currency_id or a foreign_currency_code, or neither.
        ForeignCurrencyCode   OptNilString `json:"foreign_currency_code"`
        ForeignCurrencySymbol OptNilString `json:"foreign_currency_symbol"`
        // Number of decimals in the currency.
        ForeignCurrencyDecimalPlaces OptNilInt32 `json:"foreign_currency_decimal_places"`
        // The budget ID for this transaction.
        BudgetID OptString `json:"budget_id"`
        // The name of the budget to be used. If the budget name is unknown, the ID will be used or the value
        // will be ignored.
        BudgetName OptNilString `json:"budget_name"`
        // Category ID for this transaction.
        CategoryID OptString `json:"category_id"`
        // Category name for this transaction.
        CategoryName OptString `json:"category_name"`
        // ID of the source account. Submit either this or source_name.
        SourceID OptString `json:"source_id"`
        // Name of the source account. Submit either this or source_id.
        SourceName OptString              `json:"source_name"`
        SourceIban OptNilString           `json:"source_iban"`
        SourceType OptAccountTypeProperty `json:"source_type"`
        // ID of the destination account. Submit either this or destination_name.
        DestinationID OptString `json:"destination_id"`
        // Name of the destination account. Submit either this or destination_id.
        DestinationName OptString              `json:"destination_name"`
        DestinationIban OptNilString           `json:"destination_iban"`
        DestinationType OptAccountTypeProperty `json:"destination_type"`
        // Array of tags.
        Tags OptNilStringArray `json:"tags"`
        // Optional. Use either this or the piggy_bank_name.
        PiggyBankID OptNilString `json:"piggy_bank_id"`
        // Optional. Use either this or the piggy_bank_id.
        PiggyBankName OptNilString `json:"piggy_bank_name"`
        // Optional. Use either this or the bill_name.
        BillID OptNilString `json:"bill_id"`
        // Optional. Use either this or the bill_id.
        BillName OptNilString `json:"bill_name"`
}

// GetID returns the value of ID.
func (s *RecurrenceTransaction) GetID() OptString {
        return s.ID
}

// GetDescription returns the value of Description.
func (s *RecurrenceTransaction) GetDescription() string {
        return s.Description
}

// GetAmount returns the value of Amount.
func (s *RecurrenceTransaction) GetAmount() string {
        return s.Amount
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *RecurrenceTransaction) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetCurrencyID returns the value of CurrencyID.
func (s *RecurrenceTransaction) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *RecurrenceTransaction) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *RecurrenceTransaction) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *RecurrenceTransaction) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *RecurrenceTransaction) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetForeignCurrencyCode returns the value of ForeignCurrencyCode.
func (s *RecurrenceTransaction) GetForeignCurrencyCode() OptNilString {
        return s.ForeignCurrencyCode
}

// GetForeignCurrencySymbol returns the value of ForeignCurrencySymbol.
func (s *RecurrenceTransaction) GetForeignCurrencySymbol() OptNilString {
        return s.ForeignCurrencySymbol
}

// GetForeignCurrencyDecimalPlaces returns the value of ForeignCurrencyDecimalPlaces.
func (s *RecurrenceTransaction) GetForeignCurrencyDecimalPlaces() OptNilInt32 {
        return s.ForeignCurrencyDecimalPlaces
}

// GetBudgetID returns the value of BudgetID.
func (s *RecurrenceTransaction) GetBudgetID() OptString {
        return s.BudgetID
}

// GetBudgetName returns the value of BudgetName.
func (s *RecurrenceTransaction) GetBudgetName() OptNilString {
        return s.BudgetName
}

// GetCategoryID returns the value of CategoryID.
func (s *RecurrenceTransaction) GetCategoryID() OptString {
        return s.CategoryID
}

// GetCategoryName returns the value of CategoryName.
func (s *RecurrenceTransaction) GetCategoryName() OptString {
        return s.CategoryName
}

// GetSourceID returns the value of SourceID.
func (s *RecurrenceTransaction) GetSourceID() OptString {
        return s.SourceID
}

// GetSourceName returns the value of SourceName.
func (s *RecurrenceTransaction) GetSourceName() OptString {
        return s.SourceName
}

// GetSourceIban returns the value of SourceIban.
func (s *RecurrenceTransaction) GetSourceIban() OptNilString {
        return s.SourceIban
}

// GetSourceType returns the value of SourceType.
func (s *RecurrenceTransaction) GetSourceType() OptAccountTypeProperty {
        return s.SourceType
}

// GetDestinationID returns the value of DestinationID.
func (s *RecurrenceTransaction) GetDestinationID() OptString {
        return s.DestinationID
}

// GetDestinationName returns the value of DestinationName.
func (s *RecurrenceTransaction) GetDestinationName() OptString {
        return s.DestinationName
}

// GetDestinationIban returns the value of DestinationIban.
func (s *RecurrenceTransaction) GetDestinationIban() OptNilString {
        return s.DestinationIban
}

// GetDestinationType returns the value of DestinationType.
func (s *RecurrenceTransaction) GetDestinationType() OptAccountTypeProperty {
        return s.DestinationType
}

// GetTags returns the value of Tags.
func (s *RecurrenceTransaction) GetTags() OptNilStringArray {
        return s.Tags
}

// GetPiggyBankID returns the value of PiggyBankID.
func (s *RecurrenceTransaction) GetPiggyBankID() OptNilString {
        return s.PiggyBankID
}

// GetPiggyBankName returns the value of PiggyBankName.
func (s *RecurrenceTransaction) GetPiggyBankName() OptNilString {
        return s.PiggyBankName
}

// GetBillID returns the value of BillID.
func (s *RecurrenceTransaction) GetBillID() OptNilString {
        return s.BillID
}

// GetBillName returns the value of BillName.
func (s *RecurrenceTransaction) GetBillName() OptNilString {
        return s.BillName
}

// SetID sets the value of ID.
func (s *RecurrenceTransaction) SetID(val OptString) {
        s.ID = val
}

// SetDescription sets the value of Description.
func (s *RecurrenceTransaction) SetDescription(val string) {
        s.Description = val
}

// SetAmount sets the value of Amount.
func (s *RecurrenceTransaction) SetAmount(val string) {
        s.Amount = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *RecurrenceTransaction) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *RecurrenceTransaction) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *RecurrenceTransaction) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *RecurrenceTransaction) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *RecurrenceTransaction) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *RecurrenceTransaction) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetForeignCurrencyCode sets the value of ForeignCurrencyCode.
func (s *RecurrenceTransaction) SetForeignCurrencyCode(val OptNilString) {
        s.ForeignCurrencyCode = val
}

// SetForeignCurrencySymbol sets the value of ForeignCurrencySymbol.
func (s *RecurrenceTransaction) SetForeignCurrencySymbol(val OptNilString) {
        s.ForeignCurrencySymbol = val
}

// SetForeignCurrencyDecimalPlaces sets the value of ForeignCurrencyDecimalPlaces.
func (s *RecurrenceTransaction) SetForeignCurrencyDecimalPlaces(val OptNilInt32) {
        s.ForeignCurrencyDecimalPlaces = val
}

// SetBudgetID sets the value of BudgetID.
func (s *RecurrenceTransaction) SetBudgetID(val OptString) {
        s.BudgetID = val
}

// SetBudgetName sets the value of BudgetName.
func (s *RecurrenceTransaction) SetBudgetName(val OptNilString) {
        s.BudgetName = val
}

// SetCategoryID sets the value of CategoryID.
func (s *RecurrenceTransaction) SetCategoryID(val OptString) {
        s.CategoryID = val
}

// SetCategoryName sets the value of CategoryName.
func (s *RecurrenceTransaction) SetCategoryName(val OptString) {
        s.CategoryName = val
}

// SetSourceID sets the value of SourceID.
func (s *RecurrenceTransaction) SetSourceID(val OptString) {
        s.SourceID = val
}

// SetSourceName sets the value of SourceName.
func (s *RecurrenceTransaction) SetSourceName(val OptString) {
        s.SourceName = val
}

// SetSourceIban sets the value of SourceIban.
func (s *RecurrenceTransaction) SetSourceIban(val OptNilString) {
        s.SourceIban = val
}

// SetSourceType sets the value of SourceType.
func (s *RecurrenceTransaction) SetSourceType(val OptAccountTypeProperty) {
        s.SourceType = val
}

// SetDestinationID sets the value of DestinationID.
func (s *RecurrenceTransaction) SetDestinationID(val OptString) {
        s.DestinationID = val
}

// SetDestinationName sets the value of DestinationName.
func (s *RecurrenceTransaction) SetDestinationName(val OptString) {
        s.DestinationName = val
}

// SetDestinationIban sets the value of DestinationIban.
func (s *RecurrenceTransaction) SetDestinationIban(val OptNilString) {
        s.DestinationIban = val
}

// SetDestinationType sets the value of DestinationType.
func (s *RecurrenceTransaction) SetDestinationType(val OptAccountTypeProperty) {
        s.DestinationType = val
}

// SetTags sets the value of Tags.
func (s *RecurrenceTransaction) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetPiggyBankID sets the value of PiggyBankID.
func (s *RecurrenceTransaction) SetPiggyBankID(val OptNilString) {
        s.PiggyBankID = val
}

// SetPiggyBankName sets the value of PiggyBankName.
func (s *RecurrenceTransaction) SetPiggyBankName(val OptNilString) {
        s.PiggyBankName = val
}

// SetBillID sets the value of BillID.
func (s *RecurrenceTransaction) SetBillID(val OptNilString) {
        s.BillID = val
}

// SetBillName sets the value of BillName.
func (s *RecurrenceTransaction) SetBillName(val OptNilString) {
        s.BillName = val
}

// Ref: #/components/schemas/RecurrenceTransactionStore
type RecurrenceTransactionStore struct {
        Description string `json:"description"`
        // Amount of the transaction.
        Amount string `json:"amount"`
        // Foreign amount of the transaction.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Submit either a currency_id or a currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Submit either a currency_id or a currency_code.
        CurrencyCode OptString `json:"currency_code"`
        // Submit either a foreign_currency_id or a foreign_currency_code, or neither.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // Submit either a foreign_currency_id or a foreign_currency_code, or neither.
        ForeignCurrencyCode OptNilString `json:"foreign_currency_code"`
        // The budget ID for this transaction.
        BudgetID OptString `json:"budget_id"`
        // Category ID for this transaction.
        CategoryID OptString `json:"category_id"`
        // ID of the source account.
        SourceID string `json:"source_id"`
        // ID of the destination account.
        DestinationID string `json:"destination_id"`
        // Array of tags.
        Tags OptNilStringArray `json:"tags"`
        // Optional.
        PiggyBankID OptNilString `json:"piggy_bank_id"`
        // Optional.
        BillID OptNilString `json:"bill_id"`
}

// GetDescription returns the value of Description.
func (s *RecurrenceTransactionStore) GetDescription() string {
        return s.Description
}

// GetAmount returns the value of Amount.
func (s *RecurrenceTransactionStore) GetAmount() string {
        return s.Amount
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *RecurrenceTransactionStore) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetCurrencyID returns the value of CurrencyID.
func (s *RecurrenceTransactionStore) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *RecurrenceTransactionStore) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *RecurrenceTransactionStore) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetForeignCurrencyCode returns the value of ForeignCurrencyCode.
func (s *RecurrenceTransactionStore) GetForeignCurrencyCode() OptNilString {
        return s.ForeignCurrencyCode
}

// GetBudgetID returns the value of BudgetID.
func (s *RecurrenceTransactionStore) GetBudgetID() OptString {
        return s.BudgetID
}

// GetCategoryID returns the value of CategoryID.
func (s *RecurrenceTransactionStore) GetCategoryID() OptString {
        return s.CategoryID
}

// GetSourceID returns the value of SourceID.
func (s *RecurrenceTransactionStore) GetSourceID() string {
        return s.SourceID
}

// GetDestinationID returns the value of DestinationID.
func (s *RecurrenceTransactionStore) GetDestinationID() string {
        return s.DestinationID
}

// GetTags returns the value of Tags.
func (s *RecurrenceTransactionStore) GetTags() OptNilStringArray {
        return s.Tags
}

// GetPiggyBankID returns the value of PiggyBankID.
func (s *RecurrenceTransactionStore) GetPiggyBankID() OptNilString {
        return s.PiggyBankID
}

// GetBillID returns the value of BillID.
func (s *RecurrenceTransactionStore) GetBillID() OptNilString {
        return s.BillID
}

// SetDescription sets the value of Description.
func (s *RecurrenceTransactionStore) SetDescription(val string) {
        s.Description = val
}

// SetAmount sets the value of Amount.
func (s *RecurrenceTransactionStore) SetAmount(val string) {
        s.Amount = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *RecurrenceTransactionStore) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *RecurrenceTransactionStore) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *RecurrenceTransactionStore) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *RecurrenceTransactionStore) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetForeignCurrencyCode sets the value of ForeignCurrencyCode.
func (s *RecurrenceTransactionStore) SetForeignCurrencyCode(val OptNilString) {
        s.ForeignCurrencyCode = val
}

// SetBudgetID sets the value of BudgetID.
func (s *RecurrenceTransactionStore) SetBudgetID(val OptString) {
        s.BudgetID = val
}

// SetCategoryID sets the value of CategoryID.
func (s *RecurrenceTransactionStore) SetCategoryID(val OptString) {
        s.CategoryID = val
}

// SetSourceID sets the value of SourceID.
func (s *RecurrenceTransactionStore) SetSourceID(val string) {
        s.SourceID = val
}

// SetDestinationID sets the value of DestinationID.
func (s *RecurrenceTransactionStore) SetDestinationID(val string) {
        s.DestinationID = val
}

// SetTags sets the value of Tags.
func (s *RecurrenceTransactionStore) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetPiggyBankID sets the value of PiggyBankID.
func (s *RecurrenceTransactionStore) SetPiggyBankID(val OptNilString) {
        s.PiggyBankID = val
}

// SetBillID sets the value of BillID.
func (s *RecurrenceTransactionStore) SetBillID(val OptNilString) {
        s.BillID = val
}

// Ref: #/components/schemas/RecurrenceTransactionType
type RecurrenceTransactionType string

const (
        RecurrenceTransactionTypeWithdrawal RecurrenceTransactionType = "withdrawal"
        RecurrenceTransactionTypeTransfer   RecurrenceTransactionType = "transfer"
        RecurrenceTransactionTypeDeposit    RecurrenceTransactionType = "deposit"
)

// AllValues returns all RecurrenceTransactionType values.
func (RecurrenceTransactionType) AllValues() []RecurrenceTransactionType {
        return []RecurrenceTransactionType{
                RecurrenceTransactionTypeWithdrawal,
                RecurrenceTransactionTypeTransfer,
                RecurrenceTransactionTypeDeposit,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s RecurrenceTransactionType) MarshalText() ([]byte, error) {
        switch s {
        case RecurrenceTransactionTypeWithdrawal:
                return []byte(s), nil
        case RecurrenceTransactionTypeTransfer:
                return []byte(s), nil
        case RecurrenceTransactionTypeDeposit:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *RecurrenceTransactionType) UnmarshalText(data []byte) error {
        switch RecurrenceTransactionType(data) {
        case RecurrenceTransactionTypeWithdrawal:
                *s = RecurrenceTransactionTypeWithdrawal
                return nil
        case RecurrenceTransactionTypeTransfer:
                *s = RecurrenceTransactionTypeTransfer
                return nil
        case RecurrenceTransactionTypeDeposit:
                *s = RecurrenceTransactionTypeDeposit
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/RecurrenceTransactionUpdate
type RecurrenceTransactionUpdate struct {
        ID          string    `json:"id"`
        Description OptString `json:"description"`
        // Amount of the transaction.
        Amount OptString `json:"amount"`
        // Foreign amount of the transaction.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Submit either a currency_id or a currency_code.
        CurrencyID OptString `json:"currency_id"`
        // Submit either a currency_id or a currency_code.
        CurrencyCode OptString `json:"currency_code"`
        // Submit either a foreign_currency_id or a foreign_currency_code, or neither.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // The budget ID for this transaction.
        BudgetID OptString `json:"budget_id"`
        // Category ID for this transaction.
        CategoryID OptString `json:"category_id"`
        // ID of the source account. Submit either this or source_name.
        SourceID OptString `json:"source_id"`
        // ID of the destination account. Submit either this or destination_name.
        DestinationID OptString `json:"destination_id"`
        // Array of tags.
        Tags        OptNilStringArray `json:"tags"`
        PiggyBankID OptNilString      `json:"piggy_bank_id"`
        // Optional.
        BillID OptNilString `json:"bill_id"`
}

// GetID returns the value of ID.
func (s *RecurrenceTransactionUpdate) GetID() string {
        return s.ID
}

// GetDescription returns the value of Description.
func (s *RecurrenceTransactionUpdate) GetDescription() OptString {
        return s.Description
}

// GetAmount returns the value of Amount.
func (s *RecurrenceTransactionUpdate) GetAmount() OptString {
        return s.Amount
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *RecurrenceTransactionUpdate) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetCurrencyID returns the value of CurrencyID.
func (s *RecurrenceTransactionUpdate) GetCurrencyID() OptString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *RecurrenceTransactionUpdate) GetCurrencyCode() OptString {
        return s.CurrencyCode
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *RecurrenceTransactionUpdate) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetBudgetID returns the value of BudgetID.
func (s *RecurrenceTransactionUpdate) GetBudgetID() OptString {
        return s.BudgetID
}

// GetCategoryID returns the value of CategoryID.
func (s *RecurrenceTransactionUpdate) GetCategoryID() OptString {
        return s.CategoryID
}

// GetSourceID returns the value of SourceID.
func (s *RecurrenceTransactionUpdate) GetSourceID() OptString {
        return s.SourceID
}

// GetDestinationID returns the value of DestinationID.
func (s *RecurrenceTransactionUpdate) GetDestinationID() OptString {
        return s.DestinationID
}

// GetTags returns the value of Tags.
func (s *RecurrenceTransactionUpdate) GetTags() OptNilStringArray {
        return s.Tags
}

// GetPiggyBankID returns the value of PiggyBankID.
func (s *RecurrenceTransactionUpdate) GetPiggyBankID() OptNilString {
        return s.PiggyBankID
}

// GetBillID returns the value of BillID.
func (s *RecurrenceTransactionUpdate) GetBillID() OptNilString {
        return s.BillID
}

// SetID sets the value of ID.
func (s *RecurrenceTransactionUpdate) SetID(val string) {
        s.ID = val
}

// SetDescription sets the value of Description.
func (s *RecurrenceTransactionUpdate) SetDescription(val OptString) {
        s.Description = val
}

// SetAmount sets the value of Amount.
func (s *RecurrenceTransactionUpdate) SetAmount(val OptString) {
        s.Amount = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *RecurrenceTransactionUpdate) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *RecurrenceTransactionUpdate) SetCurrencyID(val OptString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *RecurrenceTransactionUpdate) SetCurrencyCode(val OptString) {
        s.CurrencyCode = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *RecurrenceTransactionUpdate) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetBudgetID sets the value of BudgetID.
func (s *RecurrenceTransactionUpdate) SetBudgetID(val OptString) {
        s.BudgetID = val
}

// SetCategoryID sets the value of CategoryID.
func (s *RecurrenceTransactionUpdate) SetCategoryID(val OptString) {
        s.CategoryID = val
}

// SetSourceID sets the value of SourceID.
func (s *RecurrenceTransactionUpdate) SetSourceID(val OptString) {
        s.SourceID = val
}

// SetDestinationID sets the value of DestinationID.
func (s *RecurrenceTransactionUpdate) SetDestinationID(val OptString) {
        s.DestinationID = val
}

// SetTags sets the value of Tags.
func (s *RecurrenceTransactionUpdate) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetPiggyBankID sets the value of PiggyBankID.
func (s *RecurrenceTransactionUpdate) SetPiggyBankID(val OptNilString) {
        s.PiggyBankID = val
}

// SetBillID sets the value of BillID.
func (s *RecurrenceTransactionUpdate) SetBillID(val OptNilString) {
        s.BillID = val
}

// Ref: #/components/schemas/RecurrenceUpdate
type RecurrenceUpdate struct {
        Title OptString `json:"title"`
        // Not to be confused with the description of the actual transaction(s) being created.
        Description OptString `json:"description"`
        // First time the recurring transaction will fire.
        FirstDate OptDate `json:"first_date"`
        // Date until the recurring transaction can fire. After that date, it's basically inactive. Use
        // either this field or repetitions.
        RepeatUntil OptNilDate `json:"repeat_until"`
        // Max number of created transactions. Use either this field or repeat_until.
        NrOfRepetitions OptNilInt32 `json:"nr_of_repetitions"`
        // Whether or not to fire the rules after the creation of a transaction.
        ApplyRules OptBool `json:"apply_rules"`
        // If the recurrence is even active.
        Active       OptBool                       `json:"active"`
        Notes        OptNilString                  `json:"notes"`
        Repetitions  []RecurrenceRepetitionUpdate  `json:"repetitions"`
        Transactions []RecurrenceTransactionUpdate `json:"transactions"`
}

// GetTitle returns the value of Title.
func (s *RecurrenceUpdate) GetTitle() OptString {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RecurrenceUpdate) GetDescription() OptString {
        return s.Description
}

// GetFirstDate returns the value of FirstDate.
func (s *RecurrenceUpdate) GetFirstDate() OptDate {
        return s.FirstDate
}

// GetRepeatUntil returns the value of RepeatUntil.
func (s *RecurrenceUpdate) GetRepeatUntil() OptNilDate {
        return s.RepeatUntil
}

// GetNrOfRepetitions returns the value of NrOfRepetitions.
func (s *RecurrenceUpdate) GetNrOfRepetitions() OptNilInt32 {
        return s.NrOfRepetitions
}

// GetApplyRules returns the value of ApplyRules.
func (s *RecurrenceUpdate) GetApplyRules() OptBool {
        return s.ApplyRules
}

// GetActive returns the value of Active.
func (s *RecurrenceUpdate) GetActive() OptBool {
        return s.Active
}

// GetNotes returns the value of Notes.
func (s *RecurrenceUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetRepetitions returns the value of Repetitions.
func (s *RecurrenceUpdate) GetRepetitions() []RecurrenceRepetitionUpdate {
        return s.Repetitions
}

// GetTransactions returns the value of Transactions.
func (s *RecurrenceUpdate) GetTransactions() []RecurrenceTransactionUpdate {
        return s.Transactions
}

// SetTitle sets the value of Title.
func (s *RecurrenceUpdate) SetTitle(val OptString) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RecurrenceUpdate) SetDescription(val OptString) {
        s.Description = val
}

// SetFirstDate sets the value of FirstDate.
func (s *RecurrenceUpdate) SetFirstDate(val OptDate) {
        s.FirstDate = val
}

// SetRepeatUntil sets the value of RepeatUntil.
func (s *RecurrenceUpdate) SetRepeatUntil(val OptNilDate) {
        s.RepeatUntil = val
}

// SetNrOfRepetitions sets the value of NrOfRepetitions.
func (s *RecurrenceUpdate) SetNrOfRepetitions(val OptNilInt32) {
        s.NrOfRepetitions = val
}

// SetApplyRules sets the value of ApplyRules.
func (s *RecurrenceUpdate) SetApplyRules(val OptBool) {
        s.ApplyRules = val
}

// SetActive sets the value of Active.
func (s *RecurrenceUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetNotes sets the value of Notes.
func (s *RecurrenceUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetRepetitions sets the value of Repetitions.
func (s *RecurrenceUpdate) SetRepetitions(val []RecurrenceRepetitionUpdate) {
        s.Repetitions = val
}

// SetTransactions sets the value of Transactions.
func (s *RecurrenceUpdate) SetTransactions(val []RecurrenceTransactionUpdate) {
        s.Transactions = val
}

// Ref: #/components/schemas/Rule
type Rule struct {
        CreatedAt   OptDateTime `json:"created_at"`
        UpdatedAt   OptDateTime `json:"updated_at"`
        Title       string      `json:"title"`
        Description OptString   `json:"description"`
        // ID of the rule group under which the rule must be stored. Either this field or rule_group_title is
        // mandatory.
        RuleGroupID string `json:"rule_group_id"`
        // Title of the rule group under which the rule must be stored. Either this field or rule_group_id is
        // mandatory.
        RuleGroupTitle OptString       `json:"rule_group_title"`
        Order          OptInt32        `json:"order"`
        Trigger        RuleTriggerType `json:"trigger"`
        // Whether or not the rule is even active. Default is true.
        Active OptBool `json:"active"`
        // If the rule is set to be strict, ALL triggers must hit in order for the rule to fire. Otherwise,
        // just one is enough. Default value is true.
        Strict OptBool `json:"strict"`
        // If this value is true and the rule is triggered, other rules  after this one in the group will be
        // skipped. Default value is false.
        StopProcessing OptBool       `json:"stop_processing"`
        Triggers       []RuleTrigger `json:"triggers"`
        Actions        []RuleAction  `json:"actions"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Rule) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Rule) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetTitle returns the value of Title.
func (s *Rule) GetTitle() string {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *Rule) GetDescription() OptString {
        return s.Description
}

// GetRuleGroupID returns the value of RuleGroupID.
func (s *Rule) GetRuleGroupID() string {
        return s.RuleGroupID
}

// GetRuleGroupTitle returns the value of RuleGroupTitle.
func (s *Rule) GetRuleGroupTitle() OptString {
        return s.RuleGroupTitle
}

// GetOrder returns the value of Order.
func (s *Rule) GetOrder() OptInt32 {
        return s.Order
}

// GetTrigger returns the value of Trigger.
func (s *Rule) GetTrigger() RuleTriggerType {
        return s.Trigger
}

// GetActive returns the value of Active.
func (s *Rule) GetActive() OptBool {
        return s.Active
}

// GetStrict returns the value of Strict.
func (s *Rule) GetStrict() OptBool {
        return s.Strict
}

// GetStopProcessing returns the value of StopProcessing.
func (s *Rule) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// GetTriggers returns the value of Triggers.
func (s *Rule) GetTriggers() []RuleTrigger {
        return s.Triggers
}

// GetActions returns the value of Actions.
func (s *Rule) GetActions() []RuleAction {
        return s.Actions
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Rule) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Rule) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetTitle sets the value of Title.
func (s *Rule) SetTitle(val string) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *Rule) SetDescription(val OptString) {
        s.Description = val
}

// SetRuleGroupID sets the value of RuleGroupID.
func (s *Rule) SetRuleGroupID(val string) {
        s.RuleGroupID = val
}

// SetRuleGroupTitle sets the value of RuleGroupTitle.
func (s *Rule) SetRuleGroupTitle(val OptString) {
        s.RuleGroupTitle = val
}

// SetOrder sets the value of Order.
func (s *Rule) SetOrder(val OptInt32) {
        s.Order = val
}

// SetTrigger sets the value of Trigger.
func (s *Rule) SetTrigger(val RuleTriggerType) {
        s.Trigger = val
}

// SetActive sets the value of Active.
func (s *Rule) SetActive(val OptBool) {
        s.Active = val
}

// SetStrict sets the value of Strict.
func (s *Rule) SetStrict(val OptBool) {
        s.Strict = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *Rule) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// SetTriggers sets the value of Triggers.
func (s *Rule) SetTriggers(val []RuleTrigger) {
        s.Triggers = val
}

// SetActions sets the value of Actions.
func (s *Rule) SetActions(val []RuleAction) {
        s.Actions = val
}

// Ref: #/components/schemas/RuleAction
type RuleAction struct {
        ID        OptString         `json:"id"`
        CreatedAt OptDateTime       `json:"created_at"`
        UpdatedAt OptDateTime       `json:"updated_at"`
        Type      RuleActionKeyword `json:"type"`
        // The accompanying value the action will set, change or update. Can be empty, but for some types
        // this value is mandatory.
        Value NilString `json:"value"`
        // Order of the action.
        Order OptInt32 `json:"order"`
        // If the action is active. Defaults to true.
        Active OptBool `json:"active"`
        // When true, other actions will not be fired after this action has fired. Defaults to false.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetID returns the value of ID.
func (s *RuleAction) GetID() OptString {
        return s.ID
}

// GetCreatedAt returns the value of CreatedAt.
func (s *RuleAction) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *RuleAction) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetType returns the value of Type.
func (s *RuleAction) GetType() RuleActionKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleAction) GetValue() NilString {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleAction) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleAction) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleAction) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetID sets the value of ID.
func (s *RuleAction) SetID(val OptString) {
        s.ID = val
}

// SetCreatedAt sets the value of CreatedAt.
func (s *RuleAction) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *RuleAction) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetType sets the value of Type.
func (s *RuleAction) SetType(val RuleActionKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleAction) SetValue(val NilString) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleAction) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleAction) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleAction) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// The type of thing this action will do. A limited set is possible.
// Ref: #/components/schemas/RuleActionKeyword
type RuleActionKeyword string

const (
        RuleActionKeywordUserAction            RuleActionKeyword = "user_action"
        RuleActionKeywordSetCategory           RuleActionKeyword = "set_category"
        RuleActionKeywordClearCategory         RuleActionKeyword = "clear_category"
        RuleActionKeywordSetBudget             RuleActionKeyword = "set_budget"
        RuleActionKeywordClearBudget           RuleActionKeyword = "clear_budget"
        RuleActionKeywordAddTag                RuleActionKeyword = "add_tag"
        RuleActionKeywordRemoveTag             RuleActionKeyword = "remove_tag"
        RuleActionKeywordRemoveAllTags         RuleActionKeyword = "remove_all_tags"
        RuleActionKeywordSetDescription        RuleActionKeyword = "set_description"
        RuleActionKeywordAppendDescription     RuleActionKeyword = "append_description"
        RuleActionKeywordPrependDescription    RuleActionKeyword = "prepend_description"
        RuleActionKeywordSetSourceAccount      RuleActionKeyword = "set_source_account"
        RuleActionKeywordSetDestinationAccount RuleActionKeyword = "set_destination_account"
        RuleActionKeywordSetNotes              RuleActionKeyword = "set_notes"
        RuleActionKeywordAppendNotes           RuleActionKeyword = "append_notes"
        RuleActionKeywordPrependNotes          RuleActionKeyword = "prepend_notes"
        RuleActionKeywordClearNotes            RuleActionKeyword = "clear_notes"
        RuleActionKeywordLinkToBill            RuleActionKeyword = "link_to_bill"
        RuleActionKeywordConvertWithdrawal     RuleActionKeyword = "convert_withdrawal"
        RuleActionKeywordConvertDeposit        RuleActionKeyword = "convert_deposit"
        RuleActionKeywordConvertTransfer       RuleActionKeyword = "convert_transfer"
        RuleActionKeywordDeleteTransaction     RuleActionKeyword = "delete_transaction"
)

// AllValues returns all RuleActionKeyword values.
func (RuleActionKeyword) AllValues() []RuleActionKeyword {
        return []RuleActionKeyword{
                RuleActionKeywordUserAction,
                RuleActionKeywordSetCategory,
                RuleActionKeywordClearCategory,
                RuleActionKeywordSetBudget,
                RuleActionKeywordClearBudget,
                RuleActionKeywordAddTag,
                RuleActionKeywordRemoveTag,
                RuleActionKeywordRemoveAllTags,
                RuleActionKeywordSetDescription,
                RuleActionKeywordAppendDescription,
                RuleActionKeywordPrependDescription,
                RuleActionKeywordSetSourceAccount,
                RuleActionKeywordSetDestinationAccount,
                RuleActionKeywordSetNotes,
                RuleActionKeywordAppendNotes,
                RuleActionKeywordPrependNotes,
                RuleActionKeywordClearNotes,
                RuleActionKeywordLinkToBill,
                RuleActionKeywordConvertWithdrawal,
                RuleActionKeywordConvertDeposit,
                RuleActionKeywordConvertTransfer,
                RuleActionKeywordDeleteTransaction,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s RuleActionKeyword) MarshalText() ([]byte, error) {
        switch s {
        case RuleActionKeywordUserAction:
                return []byte(s), nil
        case RuleActionKeywordSetCategory:
                return []byte(s), nil
        case RuleActionKeywordClearCategory:
                return []byte(s), nil
        case RuleActionKeywordSetBudget:
                return []byte(s), nil
        case RuleActionKeywordClearBudget:
                return []byte(s), nil
        case RuleActionKeywordAddTag:
                return []byte(s), nil
        case RuleActionKeywordRemoveTag:
                return []byte(s), nil
        case RuleActionKeywordRemoveAllTags:
                return []byte(s), nil
        case RuleActionKeywordSetDescription:
                return []byte(s), nil
        case RuleActionKeywordAppendDescription:
                return []byte(s), nil
        case RuleActionKeywordPrependDescription:
                return []byte(s), nil
        case RuleActionKeywordSetSourceAccount:
                return []byte(s), nil
        case RuleActionKeywordSetDestinationAccount:
                return []byte(s), nil
        case RuleActionKeywordSetNotes:
                return []byte(s), nil
        case RuleActionKeywordAppendNotes:
                return []byte(s), nil
        case RuleActionKeywordPrependNotes:
                return []byte(s), nil
        case RuleActionKeywordClearNotes:
                return []byte(s), nil
        case RuleActionKeywordLinkToBill:
                return []byte(s), nil
        case RuleActionKeywordConvertWithdrawal:
                return []byte(s), nil
        case RuleActionKeywordConvertDeposit:
                return []byte(s), nil
        case RuleActionKeywordConvertTransfer:
                return []byte(s), nil
        case RuleActionKeywordDeleteTransaction:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *RuleActionKeyword) UnmarshalText(data []byte) error {
        switch RuleActionKeyword(data) {
        case RuleActionKeywordUserAction:
                *s = RuleActionKeywordUserAction
                return nil
        case RuleActionKeywordSetCategory:
                *s = RuleActionKeywordSetCategory
                return nil
        case RuleActionKeywordClearCategory:
                *s = RuleActionKeywordClearCategory
                return nil
        case RuleActionKeywordSetBudget:
                *s = RuleActionKeywordSetBudget
                return nil
        case RuleActionKeywordClearBudget:
                *s = RuleActionKeywordClearBudget
                return nil
        case RuleActionKeywordAddTag:
                *s = RuleActionKeywordAddTag
                return nil
        case RuleActionKeywordRemoveTag:
                *s = RuleActionKeywordRemoveTag
                return nil
        case RuleActionKeywordRemoveAllTags:
                *s = RuleActionKeywordRemoveAllTags
                return nil
        case RuleActionKeywordSetDescription:
                *s = RuleActionKeywordSetDescription
                return nil
        case RuleActionKeywordAppendDescription:
                *s = RuleActionKeywordAppendDescription
                return nil
        case RuleActionKeywordPrependDescription:
                *s = RuleActionKeywordPrependDescription
                return nil
        case RuleActionKeywordSetSourceAccount:
                *s = RuleActionKeywordSetSourceAccount
                return nil
        case RuleActionKeywordSetDestinationAccount:
                *s = RuleActionKeywordSetDestinationAccount
                return nil
        case RuleActionKeywordSetNotes:
                *s = RuleActionKeywordSetNotes
                return nil
        case RuleActionKeywordAppendNotes:
                *s = RuleActionKeywordAppendNotes
                return nil
        case RuleActionKeywordPrependNotes:
                *s = RuleActionKeywordPrependNotes
                return nil
        case RuleActionKeywordClearNotes:
                *s = RuleActionKeywordClearNotes
                return nil
        case RuleActionKeywordLinkToBill:
                *s = RuleActionKeywordLinkToBill
                return nil
        case RuleActionKeywordConvertWithdrawal:
                *s = RuleActionKeywordConvertWithdrawal
                return nil
        case RuleActionKeywordConvertDeposit:
                *s = RuleActionKeywordConvertDeposit
                return nil
        case RuleActionKeywordConvertTransfer:
                *s = RuleActionKeywordConvertTransfer
                return nil
        case RuleActionKeywordDeleteTransaction:
                *s = RuleActionKeywordDeleteTransaction
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/RuleActionStore
type RuleActionStore struct {
        Type RuleActionKeyword `json:"type"`
        // The accompanying value the action will set, change or update. Can be empty, but for some types
        // this value is mandatory.
        Value NilString `json:"value"`
        // Order of the action.
        Order OptInt32 `json:"order"`
        // If the action is active. Defaults to true.
        Active OptBool `json:"active"`
        // When true, other actions will not be fired after this action has fired. Defaults to false.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetType returns the value of Type.
func (s *RuleActionStore) GetType() RuleActionKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleActionStore) GetValue() NilString {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleActionStore) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleActionStore) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleActionStore) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetType sets the value of Type.
func (s *RuleActionStore) SetType(val RuleActionKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleActionStore) SetValue(val NilString) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleActionStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleActionStore) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleActionStore) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// Ref: #/components/schemas/RuleActionUpdate
type RuleActionUpdate struct {
        Type OptRuleActionKeyword `json:"type"`
        // The accompanying value the action will set, change or update. Can be empty, but for some types
        // this value is mandatory.
        Value OptNilString `json:"value"`
        // Order of the action.
        Order OptInt32 `json:"order"`
        // If the action is active.
        Active OptBool `json:"active"`
        // When true, other actions will not be fired after this action has fired.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetType returns the value of Type.
func (s *RuleActionUpdate) GetType() OptRuleActionKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleActionUpdate) GetValue() OptNilString {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleActionUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleActionUpdate) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleActionUpdate) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetType sets the value of Type.
func (s *RuleActionUpdate) SetType(val OptRuleActionKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleActionUpdate) SetValue(val OptNilString) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleActionUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleActionUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleActionUpdate) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// Ref: #/components/schemas/RuleArray
type RuleArray struct {
        Data  []RuleRead `json:"data"`
        Meta  Meta       `json:"meta"`
        Links PageLink   `json:"links"`
}

// GetData returns the value of Data.
func (s *RuleArray) GetData() []RuleRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *RuleArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *RuleArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *RuleArray) SetData(val []RuleRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *RuleArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *RuleArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*RuleArray) listRuleByBillRes()     {}
func (*RuleArray) listRuleByCurrencyRes() {}
func (*RuleArray) listRuleByGroupRes()    {}
func (*RuleArray) listRuleRes()           {}

// Ref: #/components/schemas/RuleGroup
type RuleGroup struct {
        CreatedAt   OptDateTime  `json:"created_at"`
        UpdatedAt   OptDateTime  `json:"updated_at"`
        Title       string       `json:"title"`
        Description OptNilString `json:"description"`
        Order       OptInt32     `json:"order"`
        Active      OptBool      `json:"active"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *RuleGroup) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *RuleGroup) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetTitle returns the value of Title.
func (s *RuleGroup) GetTitle() string {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RuleGroup) GetDescription() OptNilString {
        return s.Description
}

// GetOrder returns the value of Order.
func (s *RuleGroup) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleGroup) GetActive() OptBool {
        return s.Active
}

// SetCreatedAt sets the value of CreatedAt.
func (s *RuleGroup) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *RuleGroup) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetTitle sets the value of Title.
func (s *RuleGroup) SetTitle(val string) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RuleGroup) SetDescription(val OptNilString) {
        s.Description = val
}

// SetOrder sets the value of Order.
func (s *RuleGroup) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleGroup) SetActive(val OptBool) {
        s.Active = val
}

// Ref: #/components/schemas/RuleGroupArray
type RuleGroupArray struct {
        Data  []RuleGroupRead `json:"data"`
        Meta  Meta            `json:"meta"`
        Links PageLink        `json:"links"`
}

// GetData returns the value of Data.
func (s *RuleGroupArray) GetData() []RuleGroupRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *RuleGroupArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *RuleGroupArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *RuleGroupArray) SetData(val []RuleGroupRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *RuleGroupArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *RuleGroupArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*RuleGroupArray) listRuleGroupRes() {}

// Ref: #/components/schemas/RuleGroupRead
type RuleGroupRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes RuleGroup  `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *RuleGroupRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *RuleGroupRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *RuleGroupRead) GetAttributes() RuleGroup {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *RuleGroupRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *RuleGroupRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *RuleGroupRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *RuleGroupRead) SetAttributes(val RuleGroup) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *RuleGroupRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/RuleGroupSingle
type RuleGroupSingle struct {
        Data RuleGroupRead `json:"data"`
}

// GetData returns the value of Data.
func (s *RuleGroupSingle) GetData() RuleGroupRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *RuleGroupSingle) SetData(val RuleGroupRead) {
        s.Data = val
}

func (*RuleGroupSingle) getRuleGroupRes()    {}
func (*RuleGroupSingle) storeRuleGroupRes()  {}
func (*RuleGroupSingle) updateRuleGroupRes() {}

// Ref: #/components/schemas/RuleGroupStore
type RuleGroupStore struct {
        Title       string       `json:"title"`
        Description OptNilString `json:"description"`
        Order       OptInt32     `json:"order"`
        Active      OptBool      `json:"active"`
}

// GetTitle returns the value of Title.
func (s *RuleGroupStore) GetTitle() string {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RuleGroupStore) GetDescription() OptNilString {
        return s.Description
}

// GetOrder returns the value of Order.
func (s *RuleGroupStore) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleGroupStore) GetActive() OptBool {
        return s.Active
}

// SetTitle sets the value of Title.
func (s *RuleGroupStore) SetTitle(val string) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RuleGroupStore) SetDescription(val OptNilString) {
        s.Description = val
}

// SetOrder sets the value of Order.
func (s *RuleGroupStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleGroupStore) SetActive(val OptBool) {
        s.Active = val
}

// Ref: #/components/schemas/RuleGroupUpdate
type RuleGroupUpdate struct {
        Title       OptString    `json:"title"`
        Description OptNilString `json:"description"`
        Order       OptInt32     `json:"order"`
        Active      OptBool      `json:"active"`
}

// GetTitle returns the value of Title.
func (s *RuleGroupUpdate) GetTitle() OptString {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RuleGroupUpdate) GetDescription() OptNilString {
        return s.Description
}

// GetOrder returns the value of Order.
func (s *RuleGroupUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleGroupUpdate) GetActive() OptBool {
        return s.Active
}

// SetTitle sets the value of Title.
func (s *RuleGroupUpdate) SetTitle(val OptString) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RuleGroupUpdate) SetDescription(val OptNilString) {
        s.Description = val
}

// SetOrder sets the value of Order.
func (s *RuleGroupUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleGroupUpdate) SetActive(val OptBool) {
        s.Active = val
}

// Ref: #/components/schemas/RuleRead
type RuleRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes Rule       `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *RuleRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *RuleRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *RuleRead) GetAttributes() Rule {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *RuleRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *RuleRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *RuleRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *RuleRead) SetAttributes(val Rule) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *RuleRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/RuleSingle
type RuleSingle struct {
        Data RuleRead `json:"data"`
}

// GetData returns the value of Data.
func (s *RuleSingle) GetData() RuleRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *RuleSingle) SetData(val RuleRead) {
        s.Data = val
}

func (*RuleSingle) getRuleRes()    {}
func (*RuleSingle) storeRuleRes()  {}
func (*RuleSingle) updateRuleRes() {}

// Ref: #/components/schemas/RuleStore
type RuleStore struct {
        Title       string    `json:"title"`
        Description OptString `json:"description"`
        // ID of the rule group under which the rule must be stored. Either this field or rule_group_title is
        // mandatory.
        RuleGroupID string `json:"rule_group_id"`
        // Title of the rule group under which the rule must be stored. Either this field or rule_group_id is
        // mandatory.
        RuleGroupTitle OptString       `json:"rule_group_title"`
        Order          OptInt32        `json:"order"`
        Trigger        RuleTriggerType `json:"trigger"`
        // Whether or not the rule is even active. Default is true.
        Active OptBool `json:"active"`
        // If the rule is set to be strict, ALL triggers must hit in order for the rule to fire. Otherwise,
        // just one is enough. Default value is true.
        Strict OptBool `json:"strict"`
        // If this value is true and the rule is triggered, other rules  after this one in the group will be
        // skipped. Default value is false.
        StopProcessing OptBool            `json:"stop_processing"`
        Triggers       []RuleTriggerStore `json:"triggers"`
        Actions        []RuleActionStore  `json:"actions"`
}

// GetTitle returns the value of Title.
func (s *RuleStore) GetTitle() string {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RuleStore) GetDescription() OptString {
        return s.Description
}

// GetRuleGroupID returns the value of RuleGroupID.
func (s *RuleStore) GetRuleGroupID() string {
        return s.RuleGroupID
}

// GetRuleGroupTitle returns the value of RuleGroupTitle.
func (s *RuleStore) GetRuleGroupTitle() OptString {
        return s.RuleGroupTitle
}

// GetOrder returns the value of Order.
func (s *RuleStore) GetOrder() OptInt32 {
        return s.Order
}

// GetTrigger returns the value of Trigger.
func (s *RuleStore) GetTrigger() RuleTriggerType {
        return s.Trigger
}

// GetActive returns the value of Active.
func (s *RuleStore) GetActive() OptBool {
        return s.Active
}

// GetStrict returns the value of Strict.
func (s *RuleStore) GetStrict() OptBool {
        return s.Strict
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleStore) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// GetTriggers returns the value of Triggers.
func (s *RuleStore) GetTriggers() []RuleTriggerStore {
        return s.Triggers
}

// GetActions returns the value of Actions.
func (s *RuleStore) GetActions() []RuleActionStore {
        return s.Actions
}

// SetTitle sets the value of Title.
func (s *RuleStore) SetTitle(val string) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RuleStore) SetDescription(val OptString) {
        s.Description = val
}

// SetRuleGroupID sets the value of RuleGroupID.
func (s *RuleStore) SetRuleGroupID(val string) {
        s.RuleGroupID = val
}

// SetRuleGroupTitle sets the value of RuleGroupTitle.
func (s *RuleStore) SetRuleGroupTitle(val OptString) {
        s.RuleGroupTitle = val
}

// SetOrder sets the value of Order.
func (s *RuleStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetTrigger sets the value of Trigger.
func (s *RuleStore) SetTrigger(val RuleTriggerType) {
        s.Trigger = val
}

// SetActive sets the value of Active.
func (s *RuleStore) SetActive(val OptBool) {
        s.Active = val
}

// SetStrict sets the value of Strict.
func (s *RuleStore) SetStrict(val OptBool) {
        s.Strict = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleStore) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// SetTriggers sets the value of Triggers.
func (s *RuleStore) SetTriggers(val []RuleTriggerStore) {
        s.Triggers = val
}

// SetActions sets the value of Actions.
func (s *RuleStore) SetActions(val []RuleActionStore) {
        s.Actions = val
}

// Ref: #/components/schemas/RuleTrigger
type RuleTrigger struct {
        ID        OptString          `json:"id"`
        CreatedAt OptDateTime        `json:"created_at"`
        UpdatedAt OptDateTime        `json:"updated_at"`
        Type      RuleTriggerKeyword `json:"type"`
        // The accompanying value the triggers responds to. This value is often mandatory, but this depends
        // on the triggers.
        Value string `json:"value"`
        // Order of the triggers.
        Order OptInt32 `json:"order"`
        // If the triggers is active. Defaults to true.
        Active OptBool `json:"active"`
        // When true, other triggers will not be checked if this triggers was triggered. Defaults to false.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetID returns the value of ID.
func (s *RuleTrigger) GetID() OptString {
        return s.ID
}

// GetCreatedAt returns the value of CreatedAt.
func (s *RuleTrigger) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *RuleTrigger) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetType returns the value of Type.
func (s *RuleTrigger) GetType() RuleTriggerKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleTrigger) GetValue() string {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleTrigger) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleTrigger) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleTrigger) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetID sets the value of ID.
func (s *RuleTrigger) SetID(val OptString) {
        s.ID = val
}

// SetCreatedAt sets the value of CreatedAt.
func (s *RuleTrigger) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *RuleTrigger) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetType sets the value of Type.
func (s *RuleTrigger) SetType(val RuleTriggerKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleTrigger) SetValue(val string) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleTrigger) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleTrigger) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleTrigger) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// The type of thing this triggers responds to. A limited set is possible.
// Ref: #/components/schemas/RuleTriggerKeyword
type RuleTriggerKeyword string

const (
        RuleTriggerKeywordFromAccountStarts    RuleTriggerKeyword = "from_account_starts"
        RuleTriggerKeywordFromAccountEnds      RuleTriggerKeyword = "from_account_ends"
        RuleTriggerKeywordFromAccountIs        RuleTriggerKeyword = "from_account_is"
        RuleTriggerKeywordFromAccountContains  RuleTriggerKeyword = "from_account_contains"
        RuleTriggerKeywordToAccountStarts      RuleTriggerKeyword = "to_account_starts"
        RuleTriggerKeywordToAccountEnds        RuleTriggerKeyword = "to_account_ends"
        RuleTriggerKeywordToAccountIs          RuleTriggerKeyword = "to_account_is"
        RuleTriggerKeywordToAccountContains    RuleTriggerKeyword = "to_account_contains"
        RuleTriggerKeywordAmountLess           RuleTriggerKeyword = "amount_less"
        RuleTriggerKeywordAmountExactly        RuleTriggerKeyword = "amount_exactly"
        RuleTriggerKeywordAmountMore           RuleTriggerKeyword = "amount_more"
        RuleTriggerKeywordDescriptionStarts    RuleTriggerKeyword = "description_starts"
        RuleTriggerKeywordDescriptionEnds      RuleTriggerKeyword = "description_ends"
        RuleTriggerKeywordDescriptionContains  RuleTriggerKeyword = "description_contains"
        RuleTriggerKeywordDescriptionIs        RuleTriggerKeyword = "description_is"
        RuleTriggerKeywordTransactionType      RuleTriggerKeyword = "transaction_type"
        RuleTriggerKeywordCategoryIs           RuleTriggerKeyword = "category_is"
        RuleTriggerKeywordBudgetIs             RuleTriggerKeyword = "budget_is"
        RuleTriggerKeywordTagIs                RuleTriggerKeyword = "tag_is"
        RuleTriggerKeywordCurrencyIs           RuleTriggerKeyword = "currency_is"
        RuleTriggerKeywordHasAttachments       RuleTriggerKeyword = "has_attachments"
        RuleTriggerKeywordHasNoCategory        RuleTriggerKeyword = "has_no_category"
        RuleTriggerKeywordHasAnyCategory       RuleTriggerKeyword = "has_any_category"
        RuleTriggerKeywordHasNoBudget          RuleTriggerKeyword = "has_no_budget"
        RuleTriggerKeywordHasAnyBudget         RuleTriggerKeyword = "has_any_budget"
        RuleTriggerKeywordHasNoTag             RuleTriggerKeyword = "has_no_tag"
        RuleTriggerKeywordHasAnyTag            RuleTriggerKeyword = "has_any_tag"
        RuleTriggerKeywordNotesContains        RuleTriggerKeyword = "notes_contains"
        RuleTriggerKeywordNotesStart           RuleTriggerKeyword = "notes_start"
        RuleTriggerKeywordNotesEnd             RuleTriggerKeyword = "notes_end"
        RuleTriggerKeywordNotesAre             RuleTriggerKeyword = "notes_are"
        RuleTriggerKeywordNoNotes              RuleTriggerKeyword = "no_notes"
        RuleTriggerKeywordAnyNotes             RuleTriggerKeyword = "any_notes"
        RuleTriggerKeywordSourceAccountIs      RuleTriggerKeyword = "source_account_is"
        RuleTriggerKeywordDestinationAccountIs RuleTriggerKeyword = "destination_account_is"
        RuleTriggerKeywordSourceAccountStarts  RuleTriggerKeyword = "source_account_starts"
)

// AllValues returns all RuleTriggerKeyword values.
func (RuleTriggerKeyword) AllValues() []RuleTriggerKeyword {
        return []RuleTriggerKeyword{
                RuleTriggerKeywordFromAccountStarts,
                RuleTriggerKeywordFromAccountEnds,
                RuleTriggerKeywordFromAccountIs,
                RuleTriggerKeywordFromAccountContains,
                RuleTriggerKeywordToAccountStarts,
                RuleTriggerKeywordToAccountEnds,
                RuleTriggerKeywordToAccountIs,
                RuleTriggerKeywordToAccountContains,
                RuleTriggerKeywordAmountLess,
                RuleTriggerKeywordAmountExactly,
                RuleTriggerKeywordAmountMore,
                RuleTriggerKeywordDescriptionStarts,
                RuleTriggerKeywordDescriptionEnds,
                RuleTriggerKeywordDescriptionContains,
                RuleTriggerKeywordDescriptionIs,
                RuleTriggerKeywordTransactionType,
                RuleTriggerKeywordCategoryIs,
                RuleTriggerKeywordBudgetIs,
                RuleTriggerKeywordTagIs,
                RuleTriggerKeywordCurrencyIs,
                RuleTriggerKeywordHasAttachments,
                RuleTriggerKeywordHasNoCategory,
                RuleTriggerKeywordHasAnyCategory,
                RuleTriggerKeywordHasNoBudget,
                RuleTriggerKeywordHasAnyBudget,
                RuleTriggerKeywordHasNoTag,
                RuleTriggerKeywordHasAnyTag,
                RuleTriggerKeywordNotesContains,
                RuleTriggerKeywordNotesStart,
                RuleTriggerKeywordNotesEnd,
                RuleTriggerKeywordNotesAre,
                RuleTriggerKeywordNoNotes,
                RuleTriggerKeywordAnyNotes,
                RuleTriggerKeywordSourceAccountIs,
                RuleTriggerKeywordDestinationAccountIs,
                RuleTriggerKeywordSourceAccountStarts,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s RuleTriggerKeyword) MarshalText() ([]byte, error) {
        switch s {
        case RuleTriggerKeywordFromAccountStarts:
                return []byte(s), nil
        case RuleTriggerKeywordFromAccountEnds:
                return []byte(s), nil
        case RuleTriggerKeywordFromAccountIs:
                return []byte(s), nil
        case RuleTriggerKeywordFromAccountContains:
                return []byte(s), nil
        case RuleTriggerKeywordToAccountStarts:
                return []byte(s), nil
        case RuleTriggerKeywordToAccountEnds:
                return []byte(s), nil
        case RuleTriggerKeywordToAccountIs:
                return []byte(s), nil
        case RuleTriggerKeywordToAccountContains:
                return []byte(s), nil
        case RuleTriggerKeywordAmountLess:
                return []byte(s), nil
        case RuleTriggerKeywordAmountExactly:
                return []byte(s), nil
        case RuleTriggerKeywordAmountMore:
                return []byte(s), nil
        case RuleTriggerKeywordDescriptionStarts:
                return []byte(s), nil
        case RuleTriggerKeywordDescriptionEnds:
                return []byte(s), nil
        case RuleTriggerKeywordDescriptionContains:
                return []byte(s), nil
        case RuleTriggerKeywordDescriptionIs:
                return []byte(s), nil
        case RuleTriggerKeywordTransactionType:
                return []byte(s), nil
        case RuleTriggerKeywordCategoryIs:
                return []byte(s), nil
        case RuleTriggerKeywordBudgetIs:
                return []byte(s), nil
        case RuleTriggerKeywordTagIs:
                return []byte(s), nil
        case RuleTriggerKeywordCurrencyIs:
                return []byte(s), nil
        case RuleTriggerKeywordHasAttachments:
                return []byte(s), nil
        case RuleTriggerKeywordHasNoCategory:
                return []byte(s), nil
        case RuleTriggerKeywordHasAnyCategory:
                return []byte(s), nil
        case RuleTriggerKeywordHasNoBudget:
                return []byte(s), nil
        case RuleTriggerKeywordHasAnyBudget:
                return []byte(s), nil
        case RuleTriggerKeywordHasNoTag:
                return []byte(s), nil
        case RuleTriggerKeywordHasAnyTag:
                return []byte(s), nil
        case RuleTriggerKeywordNotesContains:
                return []byte(s), nil
        case RuleTriggerKeywordNotesStart:
                return []byte(s), nil
        case RuleTriggerKeywordNotesEnd:
                return []byte(s), nil
        case RuleTriggerKeywordNotesAre:
                return []byte(s), nil
        case RuleTriggerKeywordNoNotes:
                return []byte(s), nil
        case RuleTriggerKeywordAnyNotes:
                return []byte(s), nil
        case RuleTriggerKeywordSourceAccountIs:
                return []byte(s), nil
        case RuleTriggerKeywordDestinationAccountIs:
                return []byte(s), nil
        case RuleTriggerKeywordSourceAccountStarts:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *RuleTriggerKeyword) UnmarshalText(data []byte) error {
        switch RuleTriggerKeyword(data) {
        case RuleTriggerKeywordFromAccountStarts:
                *s = RuleTriggerKeywordFromAccountStarts
                return nil
        case RuleTriggerKeywordFromAccountEnds:
                *s = RuleTriggerKeywordFromAccountEnds
                return nil
        case RuleTriggerKeywordFromAccountIs:
                *s = RuleTriggerKeywordFromAccountIs
                return nil
        case RuleTriggerKeywordFromAccountContains:
                *s = RuleTriggerKeywordFromAccountContains
                return nil
        case RuleTriggerKeywordToAccountStarts:
                *s = RuleTriggerKeywordToAccountStarts
                return nil
        case RuleTriggerKeywordToAccountEnds:
                *s = RuleTriggerKeywordToAccountEnds
                return nil
        case RuleTriggerKeywordToAccountIs:
                *s = RuleTriggerKeywordToAccountIs
                return nil
        case RuleTriggerKeywordToAccountContains:
                *s = RuleTriggerKeywordToAccountContains
                return nil
        case RuleTriggerKeywordAmountLess:
                *s = RuleTriggerKeywordAmountLess
                return nil
        case RuleTriggerKeywordAmountExactly:
                *s = RuleTriggerKeywordAmountExactly
                return nil
        case RuleTriggerKeywordAmountMore:
                *s = RuleTriggerKeywordAmountMore
                return nil
        case RuleTriggerKeywordDescriptionStarts:
                *s = RuleTriggerKeywordDescriptionStarts
                return nil
        case RuleTriggerKeywordDescriptionEnds:
                *s = RuleTriggerKeywordDescriptionEnds
                return nil
        case RuleTriggerKeywordDescriptionContains:
                *s = RuleTriggerKeywordDescriptionContains
                return nil
        case RuleTriggerKeywordDescriptionIs:
                *s = RuleTriggerKeywordDescriptionIs
                return nil
        case RuleTriggerKeywordTransactionType:
                *s = RuleTriggerKeywordTransactionType
                return nil
        case RuleTriggerKeywordCategoryIs:
                *s = RuleTriggerKeywordCategoryIs
                return nil
        case RuleTriggerKeywordBudgetIs:
                *s = RuleTriggerKeywordBudgetIs
                return nil
        case RuleTriggerKeywordTagIs:
                *s = RuleTriggerKeywordTagIs
                return nil
        case RuleTriggerKeywordCurrencyIs:
                *s = RuleTriggerKeywordCurrencyIs
                return nil
        case RuleTriggerKeywordHasAttachments:
                *s = RuleTriggerKeywordHasAttachments
                return nil
        case RuleTriggerKeywordHasNoCategory:
                *s = RuleTriggerKeywordHasNoCategory
                return nil
        case RuleTriggerKeywordHasAnyCategory:
                *s = RuleTriggerKeywordHasAnyCategory
                return nil
        case RuleTriggerKeywordHasNoBudget:
                *s = RuleTriggerKeywordHasNoBudget
                return nil
        case RuleTriggerKeywordHasAnyBudget:
                *s = RuleTriggerKeywordHasAnyBudget
                return nil
        case RuleTriggerKeywordHasNoTag:
                *s = RuleTriggerKeywordHasNoTag
                return nil
        case RuleTriggerKeywordHasAnyTag:
                *s = RuleTriggerKeywordHasAnyTag
                return nil
        case RuleTriggerKeywordNotesContains:
                *s = RuleTriggerKeywordNotesContains
                return nil
        case RuleTriggerKeywordNotesStart:
                *s = RuleTriggerKeywordNotesStart
                return nil
        case RuleTriggerKeywordNotesEnd:
                *s = RuleTriggerKeywordNotesEnd
                return nil
        case RuleTriggerKeywordNotesAre:
                *s = RuleTriggerKeywordNotesAre
                return nil
        case RuleTriggerKeywordNoNotes:
                *s = RuleTriggerKeywordNoNotes
                return nil
        case RuleTriggerKeywordAnyNotes:
                *s = RuleTriggerKeywordAnyNotes
                return nil
        case RuleTriggerKeywordSourceAccountIs:
                *s = RuleTriggerKeywordSourceAccountIs
                return nil
        case RuleTriggerKeywordDestinationAccountIs:
                *s = RuleTriggerKeywordDestinationAccountIs
                return nil
        case RuleTriggerKeywordSourceAccountStarts:
                *s = RuleTriggerKeywordSourceAccountStarts
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/RuleTriggerStore
type RuleTriggerStore struct {
        Type RuleTriggerKeyword `json:"type"`
        // The accompanying value the triggers responds to. This value is often mandatory, but this depends
        // on the triggers.
        Value string `json:"value"`
        // Order of the triggers.
        Order OptInt32 `json:"order"`
        // If the triggers is active. Defaults to true.
        Active OptBool `json:"active"`
        // When true, other triggers will not be checked if this triggers was triggered. Defaults to false.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetType returns the value of Type.
func (s *RuleTriggerStore) GetType() RuleTriggerKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleTriggerStore) GetValue() string {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleTriggerStore) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleTriggerStore) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleTriggerStore) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetType sets the value of Type.
func (s *RuleTriggerStore) SetType(val RuleTriggerKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleTriggerStore) SetValue(val string) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleTriggerStore) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleTriggerStore) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleTriggerStore) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// Which action is necessary for the rule to fire? Use either store-journal or update-journal.
// Ref: #/components/schemas/RuleTriggerType
type RuleTriggerType string

const (
        RuleTriggerTypeStoreJournal  RuleTriggerType = "store-journal"
        RuleTriggerTypeUpdateJournal RuleTriggerType = "update-journal"
)

// AllValues returns all RuleTriggerType values.
func (RuleTriggerType) AllValues() []RuleTriggerType {
        return []RuleTriggerType{
                RuleTriggerTypeStoreJournal,
                RuleTriggerTypeUpdateJournal,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s RuleTriggerType) MarshalText() ([]byte, error) {
        switch s {
        case RuleTriggerTypeStoreJournal:
                return []byte(s), nil
        case RuleTriggerTypeUpdateJournal:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *RuleTriggerType) UnmarshalText(data []byte) error {
        switch RuleTriggerType(data) {
        case RuleTriggerTypeStoreJournal:
                *s = RuleTriggerTypeStoreJournal
                return nil
        case RuleTriggerTypeUpdateJournal:
                *s = RuleTriggerTypeUpdateJournal
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/RuleTriggerUpdate
type RuleTriggerUpdate struct {
        Type OptRuleTriggerKeyword `json:"type"`
        // The accompanying value the triggers responds to. This value is often mandatory, but this depends
        // on the triggers.
        Value OptString `json:"value"`
        // Order of the triggers.
        Order OptInt32 `json:"order"`
        // If the triggers is active.
        Active OptBool `json:"active"`
        // When true, other triggers will not be checked if this triggers was triggered.
        StopProcessing OptBool `json:"stop_processing"`
}

// GetType returns the value of Type.
func (s *RuleTriggerUpdate) GetType() OptRuleTriggerKeyword {
        return s.Type
}

// GetValue returns the value of Value.
func (s *RuleTriggerUpdate) GetValue() OptString {
        return s.Value
}

// GetOrder returns the value of Order.
func (s *RuleTriggerUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetActive returns the value of Active.
func (s *RuleTriggerUpdate) GetActive() OptBool {
        return s.Active
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleTriggerUpdate) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// SetType sets the value of Type.
func (s *RuleTriggerUpdate) SetType(val OptRuleTriggerKeyword) {
        s.Type = val
}

// SetValue sets the value of Value.
func (s *RuleTriggerUpdate) SetValue(val OptString) {
        s.Value = val
}

// SetOrder sets the value of Order.
func (s *RuleTriggerUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetActive sets the value of Active.
func (s *RuleTriggerUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleTriggerUpdate) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// Ref: #/components/schemas/RuleUpdate
type RuleUpdate struct {
        Title       OptString `json:"title"`
        Description OptString `json:"description"`
        // ID of the rule group under which the rule must be stored. Either this field or rule_group_title is
        // mandatory.
        RuleGroupID OptString          `json:"rule_group_id"`
        Order       OptInt32           `json:"order"`
        Trigger     OptRuleTriggerType `json:"trigger"`
        // Whether or not the rule is even active. Default is true.
        Active OptBool `json:"active"`
        // If the rule is set to be strict, ALL triggers must hit in order for the rule to fire. Otherwise,
        // just one is enough. Default value is true.
        Strict OptBool `json:"strict"`
        // If this value is true and the rule is triggered, other rules  after this one in the group will be
        // skipped. Default value is false.
        StopProcessing OptBool             `json:"stop_processing"`
        Triggers       []RuleTriggerUpdate `json:"triggers"`
        Actions        []RuleActionUpdate  `json:"actions"`
}

// GetTitle returns the value of Title.
func (s *RuleUpdate) GetTitle() OptString {
        return s.Title
}

// GetDescription returns the value of Description.
func (s *RuleUpdate) GetDescription() OptString {
        return s.Description
}

// GetRuleGroupID returns the value of RuleGroupID.
func (s *RuleUpdate) GetRuleGroupID() OptString {
        return s.RuleGroupID
}

// GetOrder returns the value of Order.
func (s *RuleUpdate) GetOrder() OptInt32 {
        return s.Order
}

// GetTrigger returns the value of Trigger.
func (s *RuleUpdate) GetTrigger() OptRuleTriggerType {
        return s.Trigger
}

// GetActive returns the value of Active.
func (s *RuleUpdate) GetActive() OptBool {
        return s.Active
}

// GetStrict returns the value of Strict.
func (s *RuleUpdate) GetStrict() OptBool {
        return s.Strict
}

// GetStopProcessing returns the value of StopProcessing.
func (s *RuleUpdate) GetStopProcessing() OptBool {
        return s.StopProcessing
}

// GetTriggers returns the value of Triggers.
func (s *RuleUpdate) GetTriggers() []RuleTriggerUpdate {
        return s.Triggers
}

// GetActions returns the value of Actions.
func (s *RuleUpdate) GetActions() []RuleActionUpdate {
        return s.Actions
}

// SetTitle sets the value of Title.
func (s *RuleUpdate) SetTitle(val OptString) {
        s.Title = val
}

// SetDescription sets the value of Description.
func (s *RuleUpdate) SetDescription(val OptString) {
        s.Description = val
}

// SetRuleGroupID sets the value of RuleGroupID.
func (s *RuleUpdate) SetRuleGroupID(val OptString) {
        s.RuleGroupID = val
}

// SetOrder sets the value of Order.
func (s *RuleUpdate) SetOrder(val OptInt32) {
        s.Order = val
}

// SetTrigger sets the value of Trigger.
func (s *RuleUpdate) SetTrigger(val OptRuleTriggerType) {
        s.Trigger = val
}

// SetActive sets the value of Active.
func (s *RuleUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetStrict sets the value of Strict.
func (s *RuleUpdate) SetStrict(val OptBool) {
        s.Strict = val
}

// SetStopProcessing sets the value of StopProcessing.
func (s *RuleUpdate) SetStopProcessing(val OptBool) {
        s.StopProcessing = val
}

// SetTriggers sets the value of Triggers.
func (s *RuleUpdate) SetTriggers(val []RuleTriggerUpdate) {
        s.Triggers = val
}

// SetActions sets the value of Actions.
func (s *RuleUpdate) SetActions(val []RuleActionUpdate) {
        s.Actions = val
}

// Can only be one one these account types. import, initial-balance and reconciliation cannot be set
// manually.
// Ref: #/components/schemas/ShortAccountTypeProperty
type ShortAccountTypeProperty string

const (
        ShortAccountTypePropertyAsset          ShortAccountTypeProperty = "asset"
        ShortAccountTypePropertyExpense        ShortAccountTypeProperty = "expense"
        ShortAccountTypePropertyImport         ShortAccountTypeProperty = "import"
        ShortAccountTypePropertyRevenue        ShortAccountTypeProperty = "revenue"
        ShortAccountTypePropertyCash           ShortAccountTypeProperty = "cash"
        ShortAccountTypePropertyLiability      ShortAccountTypeProperty = "liability"
        ShortAccountTypePropertyLiabilities    ShortAccountTypeProperty = "liabilities"
        ShortAccountTypePropertyInitialBalance ShortAccountTypeProperty = "initial-balance"
        ShortAccountTypePropertyReconciliation ShortAccountTypeProperty = "reconciliation"
)

// AllValues returns all ShortAccountTypeProperty values.
func (ShortAccountTypeProperty) AllValues() []ShortAccountTypeProperty {
        return []ShortAccountTypeProperty{
                ShortAccountTypePropertyAsset,
                ShortAccountTypePropertyExpense,
                ShortAccountTypePropertyImport,
                ShortAccountTypePropertyRevenue,
                ShortAccountTypePropertyCash,
                ShortAccountTypePropertyLiability,
                ShortAccountTypePropertyLiabilities,
                ShortAccountTypePropertyInitialBalance,
                ShortAccountTypePropertyReconciliation,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s ShortAccountTypeProperty) MarshalText() ([]byte, error) {
        switch s {
        case ShortAccountTypePropertyAsset:
                return []byte(s), nil
        case ShortAccountTypePropertyExpense:
                return []byte(s), nil
        case ShortAccountTypePropertyImport:
                return []byte(s), nil
        case ShortAccountTypePropertyRevenue:
                return []byte(s), nil
        case ShortAccountTypePropertyCash:
                return []byte(s), nil
        case ShortAccountTypePropertyLiability:
                return []byte(s), nil
        case ShortAccountTypePropertyLiabilities:
                return []byte(s), nil
        case ShortAccountTypePropertyInitialBalance:
                return []byte(s), nil
        case ShortAccountTypePropertyReconciliation:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *ShortAccountTypeProperty) UnmarshalText(data []byte) error {
        switch ShortAccountTypeProperty(data) {
        case ShortAccountTypePropertyAsset:
                *s = ShortAccountTypePropertyAsset
                return nil
        case ShortAccountTypePropertyExpense:
                *s = ShortAccountTypePropertyExpense
                return nil
        case ShortAccountTypePropertyImport:
                *s = ShortAccountTypePropertyImport
                return nil
        case ShortAccountTypePropertyRevenue:
                *s = ShortAccountTypePropertyRevenue
                return nil
        case ShortAccountTypePropertyCash:
                *s = ShortAccountTypePropertyCash
                return nil
        case ShortAccountTypePropertyLiability:
                *s = ShortAccountTypePropertyLiability
                return nil
        case ShortAccountTypePropertyLiabilities:
                *s = ShortAccountTypePropertyLiabilities
                return nil
        case ShortAccountTypePropertyInitialBalance:
                *s = ShortAccountTypePropertyInitialBalance
                return nil
        case ShortAccountTypePropertyReconciliation:
                *s = ShortAccountTypePropertyReconciliation
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

type StringArrayItem string

// SubmitWebookInternalServerError is response for SubmitWebook operation.
type SubmitWebookInternalServerError struct{}

func (*SubmitWebookInternalServerError) submitWebookRes() {}

// SubmitWebookNoContent is response for SubmitWebook operation.
type SubmitWebookNoContent struct{}

func (*SubmitWebookNoContent) submitWebookRes() {}

// SubmitWebookNotFound is response for SubmitWebook operation.
type SubmitWebookNotFound struct{}

func (*SubmitWebookNotFound) submitWebookRes() {}

// SubmitWebookOK is response for SubmitWebook operation.
type SubmitWebookOK struct{}

func (*SubmitWebookOK) submitWebookRes() {}

// Ref: #/components/schemas/SystemInfo
type SystemInfo struct {
        Data OptSystemInfoData `json:"data"`
}

// GetData returns the value of Data.
func (s *SystemInfo) GetData() OptSystemInfoData {
        return s.Data
}

// SetData sets the value of Data.
func (s *SystemInfo) SetData(val OptSystemInfoData) {
        s.Data = val
}

func (*SystemInfo) getAboutRes() {}

type SystemInfoData struct {
        Version    OptString `json:"version"`
        APIVersion OptString `json:"api_version"`
        PhpVersion OptString `json:"php_version"`
        Os         OptString `json:"os"`
        Driver     OptString `json:"driver"`
}

// GetVersion returns the value of Version.
func (s *SystemInfoData) GetVersion() OptString {
        return s.Version
}

// GetAPIVersion returns the value of APIVersion.
func (s *SystemInfoData) GetAPIVersion() OptString {
        return s.APIVersion
}

// GetPhpVersion returns the value of PhpVersion.
func (s *SystemInfoData) GetPhpVersion() OptString {
        return s.PhpVersion
}

// GetOs returns the value of Os.
func (s *SystemInfoData) GetOs() OptString {
        return s.Os
}

// GetDriver returns the value of Driver.
func (s *SystemInfoData) GetDriver() OptString {
        return s.Driver
}

// SetVersion sets the value of Version.
func (s *SystemInfoData) SetVersion(val OptString) {
        s.Version = val
}

// SetAPIVersion sets the value of APIVersion.
func (s *SystemInfoData) SetAPIVersion(val OptString) {
        s.APIVersion = val
}

// SetPhpVersion sets the value of PhpVersion.
func (s *SystemInfoData) SetPhpVersion(val OptString) {
        s.PhpVersion = val
}

// SetOs sets the value of Os.
func (s *SystemInfoData) SetOs(val OptString) {
        s.Os = val
}

// SetDriver sets the value of Driver.
func (s *SystemInfoData) SetDriver(val OptString) {
        s.Driver = val
}

// Ref: #/components/schemas/TagArray
type TagArray struct {
        Data  []TagRead `json:"data"`
        Meta  Meta      `json:"meta"`
        Links PageLink  `json:"links"`
}

// GetData returns the value of Data.
func (s *TagArray) GetData() []TagRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *TagArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *TagArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *TagArray) SetData(val []TagRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *TagArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *TagArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*TagArray) listTagRes() {}

// Ref: #/components/schemas/TagModel
type TagModel struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // The tag.
        Tag string `json:"tag"`
        // The date to which the tag is applicable.
        Date        OptNilDate   `json:"date"`
        Description OptNilString `json:"description"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *TagModel) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *TagModel) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetTag returns the value of Tag.
func (s *TagModel) GetTag() string {
        return s.Tag
}

// GetDate returns the value of Date.
func (s *TagModel) GetDate() OptNilDate {
        return s.Date
}

// GetDescription returns the value of Description.
func (s *TagModel) GetDescription() OptNilString {
        return s.Description
}

// GetLatitude returns the value of Latitude.
func (s *TagModel) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *TagModel) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *TagModel) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetCreatedAt sets the value of CreatedAt.
func (s *TagModel) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *TagModel) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetTag sets the value of Tag.
func (s *TagModel) SetTag(val string) {
        s.Tag = val
}

// SetDate sets the value of Date.
func (s *TagModel) SetDate(val OptNilDate) {
        s.Date = val
}

// SetDescription sets the value of Description.
func (s *TagModel) SetDescription(val OptNilString) {
        s.Description = val
}

// SetLatitude sets the value of Latitude.
func (s *TagModel) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *TagModel) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *TagModel) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// Ref: #/components/schemas/TagModelStore
type TagModelStore struct {
        // The tag.
        Tag string `json:"tag"`
        // The date to which the tag is applicable.
        Date        OptNilDate   `json:"date"`
        Description OptNilString `json:"description"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetTag returns the value of Tag.
func (s *TagModelStore) GetTag() string {
        return s.Tag
}

// GetDate returns the value of Date.
func (s *TagModelStore) GetDate() OptNilDate {
        return s.Date
}

// GetDescription returns the value of Description.
func (s *TagModelStore) GetDescription() OptNilString {
        return s.Description
}

// GetLatitude returns the value of Latitude.
func (s *TagModelStore) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *TagModelStore) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *TagModelStore) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetTag sets the value of Tag.
func (s *TagModelStore) SetTag(val string) {
        s.Tag = val
}

// SetDate sets the value of Date.
func (s *TagModelStore) SetDate(val OptNilDate) {
        s.Date = val
}

// SetDescription sets the value of Description.
func (s *TagModelStore) SetDescription(val OptNilString) {
        s.Description = val
}

// SetLatitude sets the value of Latitude.
func (s *TagModelStore) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *TagModelStore) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *TagModelStore) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// Ref: #/components/schemas/TagModelUpdate
type TagModelUpdate struct {
        // The tag.
        Tag OptString `json:"tag"`
        // The date to which the tag is applicable.
        Date        OptNilDate   `json:"date"`
        Description OptNilString `json:"description"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the tag's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
}

// GetTag returns the value of Tag.
func (s *TagModelUpdate) GetTag() OptString {
        return s.Tag
}

// GetDate returns the value of Date.
func (s *TagModelUpdate) GetDate() OptNilDate {
        return s.Date
}

// GetDescription returns the value of Description.
func (s *TagModelUpdate) GetDescription() OptNilString {
        return s.Description
}

// GetLatitude returns the value of Latitude.
func (s *TagModelUpdate) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *TagModelUpdate) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *TagModelUpdate) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// SetTag sets the value of Tag.
func (s *TagModelUpdate) SetTag(val OptString) {
        s.Tag = val
}

// SetDate sets the value of Date.
func (s *TagModelUpdate) SetDate(val OptNilDate) {
        s.Date = val
}

// SetDescription sets the value of Description.
func (s *TagModelUpdate) SetDescription(val OptNilString) {
        s.Description = val
}

// SetLatitude sets the value of Latitude.
func (s *TagModelUpdate) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *TagModelUpdate) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *TagModelUpdate) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// Ref: #/components/schemas/TagRead
type TagRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes TagModel   `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *TagRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *TagRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *TagRead) GetAttributes() TagModel {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *TagRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *TagRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *TagRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *TagRead) SetAttributes(val TagModel) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *TagRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/TagSingle
type TagSingle struct {
        Data TagRead `json:"data"`
}

// GetData returns the value of Data.
func (s *TagSingle) GetData() TagRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *TagSingle) SetData(val TagRead) {
        s.Data = val
}

func (*TagSingle) getTagRes()    {}
func (*TagSingle) storeTagRes()  {}
func (*TagSingle) updateTagRes() {}

// Ref: #/components/schemas/Transaction
type Transaction struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // User ID.
        User OptString `json:"user"`
        // Title of the transaction if it has been split in more than one piece. Empty otherwise.
        GroupTitle   OptNilString       `json:"group_title"`
        Transactions []TransactionSplit `json:"transactions"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Transaction) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Transaction) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetUser returns the value of User.
func (s *Transaction) GetUser() OptString {
        return s.User
}

// GetGroupTitle returns the value of GroupTitle.
func (s *Transaction) GetGroupTitle() OptNilString {
        return s.GroupTitle
}

// GetTransactions returns the value of Transactions.
func (s *Transaction) GetTransactions() []TransactionSplit {
        return s.Transactions
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Transaction) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Transaction) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetUser sets the value of User.
func (s *Transaction) SetUser(val OptString) {
        s.User = val
}

// SetGroupTitle sets the value of GroupTitle.
func (s *Transaction) SetGroupTitle(val OptNilString) {
        s.GroupTitle = val
}

// SetTransactions sets the value of Transactions.
func (s *Transaction) SetTransactions(val []TransactionSplit) {
        s.Transactions = val
}

// Ref: #/components/schemas/TransactionArray
type TransactionArray struct {
        Data  []TransactionRead `json:"data"`
        Meta  Meta              `json:"meta"`
        Links PageLink          `json:"links"`
}

// GetData returns the value of Data.
func (s *TransactionArray) GetData() []TransactionRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *TransactionArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *TransactionArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *TransactionArray) SetData(val []TransactionRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *TransactionArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *TransactionArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*TransactionArray) listTransactionByAccountRes()     {}
func (*TransactionArray) listTransactionByBillRes()        {}
func (*TransactionArray) listTransactionByBudgetLimitRes() {}
func (*TransactionArray) listTransactionByBudgetRes()      {}
func (*TransactionArray) listTransactionByCategoryRes()    {}
func (*TransactionArray) listTransactionByCurrencyRes()    {}
func (*TransactionArray) listTransactionByLinkTypeRes()    {}
func (*TransactionArray) listTransactionByRecurrenceRes()  {}
func (*TransactionArray) listTransactionByTagRes()         {}
func (*TransactionArray) listTransactionRes()              {}
func (*TransactionArray) searchTransactionsRes()           {}
func (*TransactionArray) testRuleGroupRes()                {}
func (*TransactionArray) testRuleRes()                     {}

// Ref: #/components/schemas/TransactionLink
type TransactionLink struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // The link type ID to use. You can also use the link_type_name field.
        LinkTypeID string `json:"link_type_id"`
        // The link type name to use. You can also use the link_type_id field.
        LinkTypeName OptString `json:"link_type_name"`
        // The inward transaction transaction_journal_id for the link. This becomes the 'is paid by'
        // transaction of the set.
        InwardID string `json:"inward_id"`
        // The outward transaction transaction_journal_id for the link. This becomes the 'pays for'
        // transaction of the set.
        OutwardID string `json:"outward_id"`
        // Optional. Some notes.
        Notes OptNilString `json:"notes"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *TransactionLink) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *TransactionLink) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetLinkTypeID returns the value of LinkTypeID.
func (s *TransactionLink) GetLinkTypeID() string {
        return s.LinkTypeID
}

// GetLinkTypeName returns the value of LinkTypeName.
func (s *TransactionLink) GetLinkTypeName() OptString {
        return s.LinkTypeName
}

// GetInwardID returns the value of InwardID.
func (s *TransactionLink) GetInwardID() string {
        return s.InwardID
}

// GetOutwardID returns the value of OutwardID.
func (s *TransactionLink) GetOutwardID() string {
        return s.OutwardID
}

// GetNotes returns the value of Notes.
func (s *TransactionLink) GetNotes() OptNilString {
        return s.Notes
}

// SetCreatedAt sets the value of CreatedAt.
func (s *TransactionLink) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *TransactionLink) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetLinkTypeID sets the value of LinkTypeID.
func (s *TransactionLink) SetLinkTypeID(val string) {
        s.LinkTypeID = val
}

// SetLinkTypeName sets the value of LinkTypeName.
func (s *TransactionLink) SetLinkTypeName(val OptString) {
        s.LinkTypeName = val
}

// SetInwardID sets the value of InwardID.
func (s *TransactionLink) SetInwardID(val string) {
        s.InwardID = val
}

// SetOutwardID sets the value of OutwardID.
func (s *TransactionLink) SetOutwardID(val string) {
        s.OutwardID = val
}

// SetNotes sets the value of Notes.
func (s *TransactionLink) SetNotes(val OptNilString) {
        s.Notes = val
}

// Ref: #/components/schemas/TransactionLinkArray
type TransactionLinkArray struct {
        Data  []TransactionLinkRead `json:"data"`
        Meta  Meta                  `json:"meta"`
        Links PageLink              `json:"links"`
}

// GetData returns the value of Data.
func (s *TransactionLinkArray) GetData() []TransactionLinkRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *TransactionLinkArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *TransactionLinkArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *TransactionLinkArray) SetData(val []TransactionLinkRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *TransactionLinkArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *TransactionLinkArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*TransactionLinkArray) listLinksByJournalRes()  {}
func (*TransactionLinkArray) listTransactionLinkRes() {}

// Ref: #/components/schemas/TransactionLinkRead
type TransactionLinkRead struct {
        // Immutable value.
        Type       string          `json:"type"`
        ID         string          `json:"id"`
        Attributes TransactionLink `json:"attributes"`
        Links      ObjectLink      `json:"links"`
}

// GetType returns the value of Type.
func (s *TransactionLinkRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *TransactionLinkRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *TransactionLinkRead) GetAttributes() TransactionLink {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *TransactionLinkRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *TransactionLinkRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *TransactionLinkRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *TransactionLinkRead) SetAttributes(val TransactionLink) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *TransactionLinkRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/TransactionLinkSingle
type TransactionLinkSingle struct {
        Data TransactionLinkRead `json:"data"`
}

// GetData returns the value of Data.
func (s *TransactionLinkSingle) GetData() TransactionLinkRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *TransactionLinkSingle) SetData(val TransactionLinkRead) {
        s.Data = val
}

func (*TransactionLinkSingle) getTransactionLinkRes()    {}
func (*TransactionLinkSingle) storeTransactionLinkRes()  {}
func (*TransactionLinkSingle) updateTransactionLinkRes() {}

// Ref: #/components/schemas/TransactionLinkStore
type TransactionLinkStore struct {
        // The link type ID to use. You can also use the link_type_name field.
        LinkTypeID string `json:"link_type_id"`
        // The link type name to use. You can also use the link_type_id field.
        LinkTypeName OptString `json:"link_type_name"`
        // The inward transaction transaction_journal_id for the link. This becomes the 'is paid by'
        // transaction of the set.
        InwardID string `json:"inward_id"`
        // The outward transaction transaction_journal_id for the link. This becomes the 'pays for'
        // transaction of the set.
        OutwardID string `json:"outward_id"`
        // Optional. Some notes.
        Notes OptNilString `json:"notes"`
}

// GetLinkTypeID returns the value of LinkTypeID.
func (s *TransactionLinkStore) GetLinkTypeID() string {
        return s.LinkTypeID
}

// GetLinkTypeName returns the value of LinkTypeName.
func (s *TransactionLinkStore) GetLinkTypeName() OptString {
        return s.LinkTypeName
}

// GetInwardID returns the value of InwardID.
func (s *TransactionLinkStore) GetInwardID() string {
        return s.InwardID
}

// GetOutwardID returns the value of OutwardID.
func (s *TransactionLinkStore) GetOutwardID() string {
        return s.OutwardID
}

// GetNotes returns the value of Notes.
func (s *TransactionLinkStore) GetNotes() OptNilString {
        return s.Notes
}

// SetLinkTypeID sets the value of LinkTypeID.
func (s *TransactionLinkStore) SetLinkTypeID(val string) {
        s.LinkTypeID = val
}

// SetLinkTypeName sets the value of LinkTypeName.
func (s *TransactionLinkStore) SetLinkTypeName(val OptString) {
        s.LinkTypeName = val
}

// SetInwardID sets the value of InwardID.
func (s *TransactionLinkStore) SetInwardID(val string) {
        s.InwardID = val
}

// SetOutwardID sets the value of OutwardID.
func (s *TransactionLinkStore) SetOutwardID(val string) {
        s.OutwardID = val
}

// SetNotes sets the value of Notes.
func (s *TransactionLinkStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// Ref: #/components/schemas/TransactionLinkUpdate
type TransactionLinkUpdate struct {
        // The link type ID to use. Use this field OR use the link_type_name field.
        LinkTypeID OptString `json:"link_type_id"`
        // The link type name to use. Use this field OR use the link_type_id field.
        LinkTypeName OptString `json:"link_type_name"`
        // The inward transaction transaction_journal_id for the link. This becomes the 'is paid by'
        // transaction of the set.
        InwardID OptString `json:"inward_id"`
        // The outward transaction transaction_journal_id for the link. This becomes the 'pays for'
        // transaction of the set.
        OutwardID OptString `json:"outward_id"`
        // Optional. Some notes. If you submit an empty string the current notes will be removed.
        Notes OptNilString `json:"notes"`
}

// GetLinkTypeID returns the value of LinkTypeID.
func (s *TransactionLinkUpdate) GetLinkTypeID() OptString {
        return s.LinkTypeID
}

// GetLinkTypeName returns the value of LinkTypeName.
func (s *TransactionLinkUpdate) GetLinkTypeName() OptString {
        return s.LinkTypeName
}

// GetInwardID returns the value of InwardID.
func (s *TransactionLinkUpdate) GetInwardID() OptString {
        return s.InwardID
}

// GetOutwardID returns the value of OutwardID.
func (s *TransactionLinkUpdate) GetOutwardID() OptString {
        return s.OutwardID
}

// GetNotes returns the value of Notes.
func (s *TransactionLinkUpdate) GetNotes() OptNilString {
        return s.Notes
}

// SetLinkTypeID sets the value of LinkTypeID.
func (s *TransactionLinkUpdate) SetLinkTypeID(val OptString) {
        s.LinkTypeID = val
}

// SetLinkTypeName sets the value of LinkTypeName.
func (s *TransactionLinkUpdate) SetLinkTypeName(val OptString) {
        s.LinkTypeName = val
}

// SetInwardID sets the value of InwardID.
func (s *TransactionLinkUpdate) SetInwardID(val OptString) {
        s.InwardID = val
}

// SetOutwardID sets the value of OutwardID.
func (s *TransactionLinkUpdate) SetOutwardID(val OptString) {
        s.OutwardID = val
}

// SetNotes sets the value of Notes.
func (s *TransactionLinkUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// Ref: #/components/schemas/TransactionRead
type TransactionRead struct {
        // Immutable value.
        Type       string      `json:"type"`
        ID         string      `json:"id"`
        Attributes Transaction `json:"attributes"`
        Links      ObjectLink  `json:"links"`
}

// GetType returns the value of Type.
func (s *TransactionRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *TransactionRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *TransactionRead) GetAttributes() Transaction {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *TransactionRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *TransactionRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *TransactionRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *TransactionRead) SetAttributes(val Transaction) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *TransactionRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Ref: #/components/schemas/TransactionSingle
type TransactionSingle struct {
        Data TransactionRead `json:"data"`
}

// GetData returns the value of Data.
func (s *TransactionSingle) GetData() TransactionRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *TransactionSingle) SetData(val TransactionRead) {
        s.Data = val
}

func (*TransactionSingle) getTransactionByJournalRes() {}
func (*TransactionSingle) getTransactionRes()          {}
func (*TransactionSingle) storeTransactionRes()        {}
func (*TransactionSingle) updateTransactionRes()       {}

// Ref: #/components/schemas/TransactionSplit
type TransactionSplit struct {
        // User ID.
        User OptString `json:"user"`
        // ID of the underlying transaction journal. Each transaction consists of a transaction group (see
        // the top ID) and one or more journals
        // making up the splits of the transaction.
        TransactionJournalID OptString               `json:"transaction_journal_id"`
        Type                 TransactionTypeProperty `json:"type"`
        // Date of the transaction.
        Date time.Time `json:"date"`
        // Order of this entry in the list of transactions.
        Order OptNilInt32 `json:"order"`
        // Currency ID. Default is the source account's currency, or the user's default currency. Can be used
        // instead of currency_code.
        CurrencyID OptNilString `json:"currency_id"`
        // Currency code. Default is the source account's currency, or the user's default currency. Can be
        // used instead of currency_id.
        CurrencyCode   OptNilString `json:"currency_code"`
        CurrencySymbol OptString    `json:"currency_symbol"`
        CurrencyName   OptString    `json:"currency_name"`
        // Number of decimals used in this currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // Currency ID of the foreign currency. Default is null. Is required when you submit a foreign amount.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // Currency code of the foreign currency. Default is NULL. Can be used instead of the
        // foreign_currency_id, but this or the ID is required when submitting a foreign amount.
        ForeignCurrencyCode   OptNilString `json:"foreign_currency_code"`
        ForeignCurrencySymbol OptNilString `json:"foreign_currency_symbol"`
        // Number of decimals in the currency.
        ForeignCurrencyDecimalPlaces OptNilInt32 `json:"foreign_currency_decimal_places"`
        // Amount of the transaction.
        Amount string `json:"amount"`
        // The amount in a foreign currency.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Description of the transaction.
        Description string `json:"description"`
        // ID of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account.
        SourceID NilString `json:"source_id"`
        // Name of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account. Can be used instead of the source_id. If the
        // transaction is a deposit, the source_name can be filled in freely: the account will be created
        // based on the name.
        SourceName OptNilString           `json:"source_name"`
        SourceIban OptNilString           `json:"source_iban"`
        SourceType OptAccountTypeProperty `json:"source_type"`
        // ID of the destination account. For a deposit or a transfer, this must always be an asset account.
        // For withdrawals this must be an expense account.
        DestinationID NilString `json:"destination_id"`
        // Name of the destination account. You can submit the name instead of the ID. For everything except
        // transfers, the account will be auto-generated if unknown, so submitting a name is enough.
        DestinationName OptNilString           `json:"destination_name"`
        DestinationIban OptNilString           `json:"destination_iban"`
        DestinationType OptAccountTypeProperty `json:"destination_type"`
        // The budget ID for this transaction.
        BudgetID OptNilString `json:"budget_id"`
        // The name of the budget to be used. If the budget name is unknown, the ID will be used or the value
        // will be ignored.
        BudgetName OptNilString `json:"budget_name"`
        // The category ID for this transaction.
        CategoryID OptNilString `json:"category_id"`
        // The name of the category to be used. If the category is unknown, it will be created. If the ID and
        // the name point to different categories, the ID overrules the name.
        CategoryName OptNilString `json:"category_name"`
        // Optional. Use either this or the bill_name.
        BillID OptNilString `json:"bill_id"`
        // Optional. Use either this or the bill_id.
        BillName OptNilString `json:"bill_name"`
        // If the transaction has been reconciled already. When you set this, the amount can no longer be
        // edited by the user.
        Reconciled OptBool      `json:"reconciled"`
        Notes      OptNilString `json:"notes"`
        // Array of tags.
        Tags OptNilStringArray `json:"tags"`
        // Reference to internal reference of other systems.
        InternalReference OptNilString `json:"internal_reference"`
        // Reference to external ID in other systems.
        ExternalID OptNilString `json:"external_id"`
        // External, custom URL for this transaction.
        ExternalURL OptNilString `json:"external_url"`
        // System generated identifier for original creator of transaction.
        OriginalSource OptNilString `json:"original_source"`
        // Reference to recurrence that made the transaction.
        RecurrenceID OptNilInt32 `json:"recurrence_id"`
        // Total number of transactions expected to be created by this recurrence repetition. Will be 0 if
        // infinite.
        RecurrenceTotal OptNilInt32 `json:"recurrence_total"`
        // The # of the current transaction created under this recurrence.
        RecurrenceCount OptNilInt32 `json:"recurrence_count"`
        // Internal ID of bunq transaction. DEPRECATED.
        BunqPaymentID OptNilString `json:"bunq_payment_id"`
        // Hash value of original import transaction (for duplicate detection).
        ImportHashV2 OptNilString `json:"import_hash_v2"`
        // SEPA Clearing Code.
        SepaCc OptNilString `json:"sepa_cc"`
        // SEPA Opposing Account Identifier.
        SepaCtOp OptNilString `json:"sepa_ct_op"`
        // SEPA end-to-end Identifier.
        SepaCtID OptNilString `json:"sepa_ct_id"`
        // SEPA mandate identifier.
        SepaDb OptNilString `json:"sepa_db"`
        // SEPA Country.
        SepaCountry OptNilString `json:"sepa_country"`
        // SEPA External Purpose indicator.
        SepaEp OptNilString `json:"sepa_ep"`
        // SEPA Creditor Identifier.
        SepaCi OptNilString `json:"sepa_ci"`
        // SEPA Batch ID.
        SepaBatchID  OptNilString   `json:"sepa_batch_id"`
        InterestDate OptNilDateTime `json:"interest_date"`
        BookDate     OptNilDateTime `json:"book_date"`
        ProcessDate  OptNilDateTime `json:"process_date"`
        DueDate      OptNilDateTime `json:"due_date"`
        PaymentDate  OptNilDateTime `json:"payment_date"`
        InvoiceDate  OptNilDateTime `json:"invoice_date"`
        // Latitude of the transaction's location, if applicable. Can be used to draw a map.
        Latitude OptNilFloat64 `json:"latitude"`
        // Latitude of the transaction's location, if applicable. Can be used to draw a map.
        Longitude OptNilFloat64 `json:"longitude"`
        // Zoom level for the map, if drawn. This to set the box right. Unfortunately this is a proprietary
        // value because each map provider has different zoom levels.
        ZoomLevel OptNilInt32 `json:"zoom_level"`
        // If the transaction has attachments.
        HasAttachments OptBool `json:"has_attachments"`
}

// GetUser returns the value of User.
func (s *TransactionSplit) GetUser() OptString {
        return s.User
}

// GetTransactionJournalID returns the value of TransactionJournalID.
func (s *TransactionSplit) GetTransactionJournalID() OptString {
        return s.TransactionJournalID
}

// GetType returns the value of Type.
func (s *TransactionSplit) GetType() TransactionTypeProperty {
        return s.Type
}

// GetDate returns the value of Date.
func (s *TransactionSplit) GetDate() time.Time {
        return s.Date
}

// GetOrder returns the value of Order.
func (s *TransactionSplit) GetOrder() OptNilInt32 {
        return s.Order
}

// GetCurrencyID returns the value of CurrencyID.
func (s *TransactionSplit) GetCurrencyID() OptNilString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *TransactionSplit) GetCurrencyCode() OptNilString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *TransactionSplit) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyName returns the value of CurrencyName.
func (s *TransactionSplit) GetCurrencyName() OptString {
        return s.CurrencyName
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *TransactionSplit) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *TransactionSplit) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetForeignCurrencyCode returns the value of ForeignCurrencyCode.
func (s *TransactionSplit) GetForeignCurrencyCode() OptNilString {
        return s.ForeignCurrencyCode
}

// GetForeignCurrencySymbol returns the value of ForeignCurrencySymbol.
func (s *TransactionSplit) GetForeignCurrencySymbol() OptNilString {
        return s.ForeignCurrencySymbol
}

// GetForeignCurrencyDecimalPlaces returns the value of ForeignCurrencyDecimalPlaces.
func (s *TransactionSplit) GetForeignCurrencyDecimalPlaces() OptNilInt32 {
        return s.ForeignCurrencyDecimalPlaces
}

// GetAmount returns the value of Amount.
func (s *TransactionSplit) GetAmount() string {
        return s.Amount
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *TransactionSplit) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetDescription returns the value of Description.
func (s *TransactionSplit) GetDescription() string {
        return s.Description
}

// GetSourceID returns the value of SourceID.
func (s *TransactionSplit) GetSourceID() NilString {
        return s.SourceID
}

// GetSourceName returns the value of SourceName.
func (s *TransactionSplit) GetSourceName() OptNilString {
        return s.SourceName
}

// GetSourceIban returns the value of SourceIban.
func (s *TransactionSplit) GetSourceIban() OptNilString {
        return s.SourceIban
}

// GetSourceType returns the value of SourceType.
func (s *TransactionSplit) GetSourceType() OptAccountTypeProperty {
        return s.SourceType
}

// GetDestinationID returns the value of DestinationID.
func (s *TransactionSplit) GetDestinationID() NilString {
        return s.DestinationID
}

// GetDestinationName returns the value of DestinationName.
func (s *TransactionSplit) GetDestinationName() OptNilString {
        return s.DestinationName
}

// GetDestinationIban returns the value of DestinationIban.
func (s *TransactionSplit) GetDestinationIban() OptNilString {
        return s.DestinationIban
}

// GetDestinationType returns the value of DestinationType.
func (s *TransactionSplit) GetDestinationType() OptAccountTypeProperty {
        return s.DestinationType
}

// GetBudgetID returns the value of BudgetID.
func (s *TransactionSplit) GetBudgetID() OptNilString {
        return s.BudgetID
}

// GetBudgetName returns the value of BudgetName.
func (s *TransactionSplit) GetBudgetName() OptNilString {
        return s.BudgetName
}

// GetCategoryID returns the value of CategoryID.
func (s *TransactionSplit) GetCategoryID() OptNilString {
        return s.CategoryID
}

// GetCategoryName returns the value of CategoryName.
func (s *TransactionSplit) GetCategoryName() OptNilString {
        return s.CategoryName
}

// GetBillID returns the value of BillID.
func (s *TransactionSplit) GetBillID() OptNilString {
        return s.BillID
}

// GetBillName returns the value of BillName.
func (s *TransactionSplit) GetBillName() OptNilString {
        return s.BillName
}

// GetReconciled returns the value of Reconciled.
func (s *TransactionSplit) GetReconciled() OptBool {
        return s.Reconciled
}

// GetNotes returns the value of Notes.
func (s *TransactionSplit) GetNotes() OptNilString {
        return s.Notes
}

// GetTags returns the value of Tags.
func (s *TransactionSplit) GetTags() OptNilStringArray {
        return s.Tags
}

// GetInternalReference returns the value of InternalReference.
func (s *TransactionSplit) GetInternalReference() OptNilString {
        return s.InternalReference
}

// GetExternalID returns the value of ExternalID.
func (s *TransactionSplit) GetExternalID() OptNilString {
        return s.ExternalID
}

// GetExternalURL returns the value of ExternalURL.
func (s *TransactionSplit) GetExternalURL() OptNilString {
        return s.ExternalURL
}

// GetOriginalSource returns the value of OriginalSource.
func (s *TransactionSplit) GetOriginalSource() OptNilString {
        return s.OriginalSource
}

// GetRecurrenceID returns the value of RecurrenceID.
func (s *TransactionSplit) GetRecurrenceID() OptNilInt32 {
        return s.RecurrenceID
}

// GetRecurrenceTotal returns the value of RecurrenceTotal.
func (s *TransactionSplit) GetRecurrenceTotal() OptNilInt32 {
        return s.RecurrenceTotal
}

// GetRecurrenceCount returns the value of RecurrenceCount.
func (s *TransactionSplit) GetRecurrenceCount() OptNilInt32 {
        return s.RecurrenceCount
}

// GetBunqPaymentID returns the value of BunqPaymentID.
func (s *TransactionSplit) GetBunqPaymentID() OptNilString {
        return s.BunqPaymentID
}

// GetImportHashV2 returns the value of ImportHashV2.
func (s *TransactionSplit) GetImportHashV2() OptNilString {
        return s.ImportHashV2
}

// GetSepaCc returns the value of SepaCc.
func (s *TransactionSplit) GetSepaCc() OptNilString {
        return s.SepaCc
}

// GetSepaCtOp returns the value of SepaCtOp.
func (s *TransactionSplit) GetSepaCtOp() OptNilString {
        return s.SepaCtOp
}

// GetSepaCtID returns the value of SepaCtID.
func (s *TransactionSplit) GetSepaCtID() OptNilString {
        return s.SepaCtID
}

// GetSepaDb returns the value of SepaDb.
func (s *TransactionSplit) GetSepaDb() OptNilString {
        return s.SepaDb
}

// GetSepaCountry returns the value of SepaCountry.
func (s *TransactionSplit) GetSepaCountry() OptNilString {
        return s.SepaCountry
}

// GetSepaEp returns the value of SepaEp.
func (s *TransactionSplit) GetSepaEp() OptNilString {
        return s.SepaEp
}

// GetSepaCi returns the value of SepaCi.
func (s *TransactionSplit) GetSepaCi() OptNilString {
        return s.SepaCi
}

// GetSepaBatchID returns the value of SepaBatchID.
func (s *TransactionSplit) GetSepaBatchID() OptNilString {
        return s.SepaBatchID
}

// GetInterestDate returns the value of InterestDate.
func (s *TransactionSplit) GetInterestDate() OptNilDateTime {
        return s.InterestDate
}

// GetBookDate returns the value of BookDate.
func (s *TransactionSplit) GetBookDate() OptNilDateTime {
        return s.BookDate
}

// GetProcessDate returns the value of ProcessDate.
func (s *TransactionSplit) GetProcessDate() OptNilDateTime {
        return s.ProcessDate
}

// GetDueDate returns the value of DueDate.
func (s *TransactionSplit) GetDueDate() OptNilDateTime {
        return s.DueDate
}

// GetPaymentDate returns the value of PaymentDate.
func (s *TransactionSplit) GetPaymentDate() OptNilDateTime {
        return s.PaymentDate
}

// GetInvoiceDate returns the value of InvoiceDate.
func (s *TransactionSplit) GetInvoiceDate() OptNilDateTime {
        return s.InvoiceDate
}

// GetLatitude returns the value of Latitude.
func (s *TransactionSplit) GetLatitude() OptNilFloat64 {
        return s.Latitude
}

// GetLongitude returns the value of Longitude.
func (s *TransactionSplit) GetLongitude() OptNilFloat64 {
        return s.Longitude
}

// GetZoomLevel returns the value of ZoomLevel.
func (s *TransactionSplit) GetZoomLevel() OptNilInt32 {
        return s.ZoomLevel
}

// GetHasAttachments returns the value of HasAttachments.
func (s *TransactionSplit) GetHasAttachments() OptBool {
        return s.HasAttachments
}

// SetUser sets the value of User.
func (s *TransactionSplit) SetUser(val OptString) {
        s.User = val
}

// SetTransactionJournalID sets the value of TransactionJournalID.
func (s *TransactionSplit) SetTransactionJournalID(val OptString) {
        s.TransactionJournalID = val
}

// SetType sets the value of Type.
func (s *TransactionSplit) SetType(val TransactionTypeProperty) {
        s.Type = val
}

// SetDate sets the value of Date.
func (s *TransactionSplit) SetDate(val time.Time) {
        s.Date = val
}

// SetOrder sets the value of Order.
func (s *TransactionSplit) SetOrder(val OptNilInt32) {
        s.Order = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *TransactionSplit) SetCurrencyID(val OptNilString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *TransactionSplit) SetCurrencyCode(val OptNilString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *TransactionSplit) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyName sets the value of CurrencyName.
func (s *TransactionSplit) SetCurrencyName(val OptString) {
        s.CurrencyName = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *TransactionSplit) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *TransactionSplit) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetForeignCurrencyCode sets the value of ForeignCurrencyCode.
func (s *TransactionSplit) SetForeignCurrencyCode(val OptNilString) {
        s.ForeignCurrencyCode = val
}

// SetForeignCurrencySymbol sets the value of ForeignCurrencySymbol.
func (s *TransactionSplit) SetForeignCurrencySymbol(val OptNilString) {
        s.ForeignCurrencySymbol = val
}

// SetForeignCurrencyDecimalPlaces sets the value of ForeignCurrencyDecimalPlaces.
func (s *TransactionSplit) SetForeignCurrencyDecimalPlaces(val OptNilInt32) {
        s.ForeignCurrencyDecimalPlaces = val
}

// SetAmount sets the value of Amount.
func (s *TransactionSplit) SetAmount(val string) {
        s.Amount = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *TransactionSplit) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetDescription sets the value of Description.
func (s *TransactionSplit) SetDescription(val string) {
        s.Description = val
}

// SetSourceID sets the value of SourceID.
func (s *TransactionSplit) SetSourceID(val NilString) {
        s.SourceID = val
}

// SetSourceName sets the value of SourceName.
func (s *TransactionSplit) SetSourceName(val OptNilString) {
        s.SourceName = val
}

// SetSourceIban sets the value of SourceIban.
func (s *TransactionSplit) SetSourceIban(val OptNilString) {
        s.SourceIban = val
}

// SetSourceType sets the value of SourceType.
func (s *TransactionSplit) SetSourceType(val OptAccountTypeProperty) {
        s.SourceType = val
}

// SetDestinationID sets the value of DestinationID.
func (s *TransactionSplit) SetDestinationID(val NilString) {
        s.DestinationID = val
}

// SetDestinationName sets the value of DestinationName.
func (s *TransactionSplit) SetDestinationName(val OptNilString) {
        s.DestinationName = val
}

// SetDestinationIban sets the value of DestinationIban.
func (s *TransactionSplit) SetDestinationIban(val OptNilString) {
        s.DestinationIban = val
}

// SetDestinationType sets the value of DestinationType.
func (s *TransactionSplit) SetDestinationType(val OptAccountTypeProperty) {
        s.DestinationType = val
}

// SetBudgetID sets the value of BudgetID.
func (s *TransactionSplit) SetBudgetID(val OptNilString) {
        s.BudgetID = val
}

// SetBudgetName sets the value of BudgetName.
func (s *TransactionSplit) SetBudgetName(val OptNilString) {
        s.BudgetName = val
}

// SetCategoryID sets the value of CategoryID.
func (s *TransactionSplit) SetCategoryID(val OptNilString) {
        s.CategoryID = val
}

// SetCategoryName sets the value of CategoryName.
func (s *TransactionSplit) SetCategoryName(val OptNilString) {
        s.CategoryName = val
}

// SetBillID sets the value of BillID.
func (s *TransactionSplit) SetBillID(val OptNilString) {
        s.BillID = val
}

// SetBillName sets the value of BillName.
func (s *TransactionSplit) SetBillName(val OptNilString) {
        s.BillName = val
}

// SetReconciled sets the value of Reconciled.
func (s *TransactionSplit) SetReconciled(val OptBool) {
        s.Reconciled = val
}

// SetNotes sets the value of Notes.
func (s *TransactionSplit) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetTags sets the value of Tags.
func (s *TransactionSplit) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetInternalReference sets the value of InternalReference.
func (s *TransactionSplit) SetInternalReference(val OptNilString) {
        s.InternalReference = val
}

// SetExternalID sets the value of ExternalID.
func (s *TransactionSplit) SetExternalID(val OptNilString) {
        s.ExternalID = val
}

// SetExternalURL sets the value of ExternalURL.
func (s *TransactionSplit) SetExternalURL(val OptNilString) {
        s.ExternalURL = val
}

// SetOriginalSource sets the value of OriginalSource.
func (s *TransactionSplit) SetOriginalSource(val OptNilString) {
        s.OriginalSource = val
}

// SetRecurrenceID sets the value of RecurrenceID.
func (s *TransactionSplit) SetRecurrenceID(val OptNilInt32) {
        s.RecurrenceID = val
}

// SetRecurrenceTotal sets the value of RecurrenceTotal.
func (s *TransactionSplit) SetRecurrenceTotal(val OptNilInt32) {
        s.RecurrenceTotal = val
}

// SetRecurrenceCount sets the value of RecurrenceCount.
func (s *TransactionSplit) SetRecurrenceCount(val OptNilInt32) {
        s.RecurrenceCount = val
}

// SetBunqPaymentID sets the value of BunqPaymentID.
func (s *TransactionSplit) SetBunqPaymentID(val OptNilString) {
        s.BunqPaymentID = val
}

// SetImportHashV2 sets the value of ImportHashV2.
func (s *TransactionSplit) SetImportHashV2(val OptNilString) {
        s.ImportHashV2 = val
}

// SetSepaCc sets the value of SepaCc.
func (s *TransactionSplit) SetSepaCc(val OptNilString) {
        s.SepaCc = val
}

// SetSepaCtOp sets the value of SepaCtOp.
func (s *TransactionSplit) SetSepaCtOp(val OptNilString) {
        s.SepaCtOp = val
}

// SetSepaCtID sets the value of SepaCtID.
func (s *TransactionSplit) SetSepaCtID(val OptNilString) {
        s.SepaCtID = val
}

// SetSepaDb sets the value of SepaDb.
func (s *TransactionSplit) SetSepaDb(val OptNilString) {
        s.SepaDb = val
}

// SetSepaCountry sets the value of SepaCountry.
func (s *TransactionSplit) SetSepaCountry(val OptNilString) {
        s.SepaCountry = val
}

// SetSepaEp sets the value of SepaEp.
func (s *TransactionSplit) SetSepaEp(val OptNilString) {
        s.SepaEp = val
}

// SetSepaCi sets the value of SepaCi.
func (s *TransactionSplit) SetSepaCi(val OptNilString) {
        s.SepaCi = val
}

// SetSepaBatchID sets the value of SepaBatchID.
func (s *TransactionSplit) SetSepaBatchID(val OptNilString) {
        s.SepaBatchID = val
}

// SetInterestDate sets the value of InterestDate.
func (s *TransactionSplit) SetInterestDate(val OptNilDateTime) {
        s.InterestDate = val
}

// SetBookDate sets the value of BookDate.
func (s *TransactionSplit) SetBookDate(val OptNilDateTime) {
        s.BookDate = val
}

// SetProcessDate sets the value of ProcessDate.
func (s *TransactionSplit) SetProcessDate(val OptNilDateTime) {
        s.ProcessDate = val
}

// SetDueDate sets the value of DueDate.
func (s *TransactionSplit) SetDueDate(val OptNilDateTime) {
        s.DueDate = val
}

// SetPaymentDate sets the value of PaymentDate.
func (s *TransactionSplit) SetPaymentDate(val OptNilDateTime) {
        s.PaymentDate = val
}

// SetInvoiceDate sets the value of InvoiceDate.
func (s *TransactionSplit) SetInvoiceDate(val OptNilDateTime) {
        s.InvoiceDate = val
}

// SetLatitude sets the value of Latitude.
func (s *TransactionSplit) SetLatitude(val OptNilFloat64) {
        s.Latitude = val
}

// SetLongitude sets the value of Longitude.
func (s *TransactionSplit) SetLongitude(val OptNilFloat64) {
        s.Longitude = val
}

// SetZoomLevel sets the value of ZoomLevel.
func (s *TransactionSplit) SetZoomLevel(val OptNilInt32) {
        s.ZoomLevel = val
}

// SetHasAttachments sets the value of HasAttachments.
func (s *TransactionSplit) SetHasAttachments(val OptBool) {
        s.HasAttachments = val
}

// Ref: #/components/schemas/TransactionSplitStore
type TransactionSplitStore struct {
        Type TransactionTypeProperty `json:"type"`
        // Date of the transaction.
        Date time.Time `json:"date"`
        // Amount of the transaction.
        Amount string `json:"amount"`
        // Description of the transaction.
        Description string `json:"description"`
        // Order of this entry in the list of transactions.
        Order OptNilInt32 `json:"order"`
        // Currency ID. Default is the source account's currency, or the user's default currency. The value
        // you submit may be overruled by the source or destination account.
        CurrencyID OptNilString `json:"currency_id"`
        // Currency code. Default is the source account's currency, or the user's default currency. The value
        // you submit may be overruled by the source or destination account.
        CurrencyCode OptNilString `json:"currency_code"`
        // The amount in a foreign currency.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Currency ID of the foreign currency. Default is null. Is required when you submit a foreign amount.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // Currency code of the foreign currency. Default is NULL. Can be used instead of the
        // foreign_currency_id, but this or the ID is required when submitting a foreign amount.
        ForeignCurrencyCode OptNilString `json:"foreign_currency_code"`
        // The budget ID for this transaction.
        BudgetID OptNilString `json:"budget_id"`
        // The name of the budget to be used. If the budget name is unknown, the ID will be used or the value
        // will be ignored.
        BudgetName OptNilString `json:"budget_name"`
        // The category ID for this transaction.
        CategoryID OptNilString `json:"category_id"`
        // The name of the category to be used. If the category is unknown, it will be created. If the ID and
        // the name point to different categories, the ID overrules the name.
        CategoryName OptNilString `json:"category_name"`
        // ID of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account.
        SourceID OptNilString `json:"source_id"`
        // Name of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account. Can be used instead of the source_id. If the
        // transaction is a deposit, the source_name can be filled in freely: the account will be created
        // based on the name.
        SourceName OptNilString `json:"source_name"`
        // ID of the destination account. For a deposit or a transfer, this must always be an asset account.
        // For withdrawals this must be an expense account.
        DestinationID OptNilString `json:"destination_id"`
        // Name of the destination account. You can submit the name instead of the ID. For everything except
        // transfers, the account will be auto-generated if unknown, so submitting a name is enough.
        DestinationName OptNilString `json:"destination_name"`
        // If the transaction has been reconciled already. When you set this, the amount can no longer be
        // edited by the user.
        Reconciled OptBool `json:"reconciled"`
        // Optional. Use either this or the piggy_bank_name.
        PiggyBankID OptInt32 `json:"piggy_bank_id"`
        // Optional. Use either this or the piggy_bank_id.
        PiggyBankName OptString `json:"piggy_bank_name"`
        // Optional. Use either this or the bill_name.
        BillID OptNilString `json:"bill_id"`
        // Optional. Use either this or the bill_id.
        BillName OptNilString `json:"bill_name"`
        // Array of tags.
        Tags  OptNilStringArray `json:"tags"`
        Notes OptNilString      `json:"notes"`
        // Reference to internal reference of other systems.
        InternalReference OptNilString `json:"internal_reference"`
        // Reference to external ID in other systems.
        ExternalID OptNilString `json:"external_id"`
        // External, custom URL for this transaction.
        ExternalURL OptNilString `json:"external_url"`
        // Internal ID of bunq transaction. Field is no longer used but still works.
        BunqPaymentID OptNilString `json:"bunq_payment_id"`
        // SEPA Clearing Code.
        SepaCc OptNilString `json:"sepa_cc"`
        // SEPA Opposing Account Identifier.
        SepaCtOp OptNilString `json:"sepa_ct_op"`
        // SEPA end-to-end Identifier.
        SepaCtID OptNilString `json:"sepa_ct_id"`
        // SEPA mandate identifier.
        SepaDb OptNilString `json:"sepa_db"`
        // SEPA Country.
        SepaCountry OptNilString `json:"sepa_country"`
        // SEPA External Purpose indicator.
        SepaEp OptNilString `json:"sepa_ep"`
        // SEPA Creditor Identifier.
        SepaCi OptNilString `json:"sepa_ci"`
        // SEPA Batch ID.
        SepaBatchID  OptNilString   `json:"sepa_batch_id"`
        InterestDate OptNilDateTime `json:"interest_date"`
        BookDate     OptNilDateTime `json:"book_date"`
        ProcessDate  OptNilDateTime `json:"process_date"`
        DueDate      OptNilDateTime `json:"due_date"`
        PaymentDate  OptNilDateTime `json:"payment_date"`
        InvoiceDate  OptNilDateTime `json:"invoice_date"`
}

// GetType returns the value of Type.
func (s *TransactionSplitStore) GetType() TransactionTypeProperty {
        return s.Type
}

// GetDate returns the value of Date.
func (s *TransactionSplitStore) GetDate() time.Time {
        return s.Date
}

// GetAmount returns the value of Amount.
func (s *TransactionSplitStore) GetAmount() string {
        return s.Amount
}

// GetDescription returns the value of Description.
func (s *TransactionSplitStore) GetDescription() string {
        return s.Description
}

// GetOrder returns the value of Order.
func (s *TransactionSplitStore) GetOrder() OptNilInt32 {
        return s.Order
}

// GetCurrencyID returns the value of CurrencyID.
func (s *TransactionSplitStore) GetCurrencyID() OptNilString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *TransactionSplitStore) GetCurrencyCode() OptNilString {
        return s.CurrencyCode
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *TransactionSplitStore) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *TransactionSplitStore) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetForeignCurrencyCode returns the value of ForeignCurrencyCode.
func (s *TransactionSplitStore) GetForeignCurrencyCode() OptNilString {
        return s.ForeignCurrencyCode
}

// GetBudgetID returns the value of BudgetID.
func (s *TransactionSplitStore) GetBudgetID() OptNilString {
        return s.BudgetID
}

// GetBudgetName returns the value of BudgetName.
func (s *TransactionSplitStore) GetBudgetName() OptNilString {
        return s.BudgetName
}

// GetCategoryID returns the value of CategoryID.
func (s *TransactionSplitStore) GetCategoryID() OptNilString {
        return s.CategoryID
}

// GetCategoryName returns the value of CategoryName.
func (s *TransactionSplitStore) GetCategoryName() OptNilString {
        return s.CategoryName
}

// GetSourceID returns the value of SourceID.
func (s *TransactionSplitStore) GetSourceID() OptNilString {
        return s.SourceID
}

// GetSourceName returns the value of SourceName.
func (s *TransactionSplitStore) GetSourceName() OptNilString {
        return s.SourceName
}

// GetDestinationID returns the value of DestinationID.
func (s *TransactionSplitStore) GetDestinationID() OptNilString {
        return s.DestinationID
}

// GetDestinationName returns the value of DestinationName.
func (s *TransactionSplitStore) GetDestinationName() OptNilString {
        return s.DestinationName
}

// GetReconciled returns the value of Reconciled.
func (s *TransactionSplitStore) GetReconciled() OptBool {
        return s.Reconciled
}

// GetPiggyBankID returns the value of PiggyBankID.
func (s *TransactionSplitStore) GetPiggyBankID() OptInt32 {
        return s.PiggyBankID
}

// GetPiggyBankName returns the value of PiggyBankName.
func (s *TransactionSplitStore) GetPiggyBankName() OptString {
        return s.PiggyBankName
}

// GetBillID returns the value of BillID.
func (s *TransactionSplitStore) GetBillID() OptNilString {
        return s.BillID
}

// GetBillName returns the value of BillName.
func (s *TransactionSplitStore) GetBillName() OptNilString {
        return s.BillName
}

// GetTags returns the value of Tags.
func (s *TransactionSplitStore) GetTags() OptNilStringArray {
        return s.Tags
}

// GetNotes returns the value of Notes.
func (s *TransactionSplitStore) GetNotes() OptNilString {
        return s.Notes
}

// GetInternalReference returns the value of InternalReference.
func (s *TransactionSplitStore) GetInternalReference() OptNilString {
        return s.InternalReference
}

// GetExternalID returns the value of ExternalID.
func (s *TransactionSplitStore) GetExternalID() OptNilString {
        return s.ExternalID
}

// GetExternalURL returns the value of ExternalURL.
func (s *TransactionSplitStore) GetExternalURL() OptNilString {
        return s.ExternalURL
}

// GetBunqPaymentID returns the value of BunqPaymentID.
func (s *TransactionSplitStore) GetBunqPaymentID() OptNilString {
        return s.BunqPaymentID
}

// GetSepaCc returns the value of SepaCc.
func (s *TransactionSplitStore) GetSepaCc() OptNilString {
        return s.SepaCc
}

// GetSepaCtOp returns the value of SepaCtOp.
func (s *TransactionSplitStore) GetSepaCtOp() OptNilString {
        return s.SepaCtOp
}

// GetSepaCtID returns the value of SepaCtID.
func (s *TransactionSplitStore) GetSepaCtID() OptNilString {
        return s.SepaCtID
}

// GetSepaDb returns the value of SepaDb.
func (s *TransactionSplitStore) GetSepaDb() OptNilString {
        return s.SepaDb
}

// GetSepaCountry returns the value of SepaCountry.
func (s *TransactionSplitStore) GetSepaCountry() OptNilString {
        return s.SepaCountry
}

// GetSepaEp returns the value of SepaEp.
func (s *TransactionSplitStore) GetSepaEp() OptNilString {
        return s.SepaEp
}

// GetSepaCi returns the value of SepaCi.
func (s *TransactionSplitStore) GetSepaCi() OptNilString {
        return s.SepaCi
}

// GetSepaBatchID returns the value of SepaBatchID.
func (s *TransactionSplitStore) GetSepaBatchID() OptNilString {
        return s.SepaBatchID
}

// GetInterestDate returns the value of InterestDate.
func (s *TransactionSplitStore) GetInterestDate() OptNilDateTime {
        return s.InterestDate
}

// GetBookDate returns the value of BookDate.
func (s *TransactionSplitStore) GetBookDate() OptNilDateTime {
        return s.BookDate
}

// GetProcessDate returns the value of ProcessDate.
func (s *TransactionSplitStore) GetProcessDate() OptNilDateTime {
        return s.ProcessDate
}

// GetDueDate returns the value of DueDate.
func (s *TransactionSplitStore) GetDueDate() OptNilDateTime {
        return s.DueDate
}

// GetPaymentDate returns the value of PaymentDate.
func (s *TransactionSplitStore) GetPaymentDate() OptNilDateTime {
        return s.PaymentDate
}

// GetInvoiceDate returns the value of InvoiceDate.
func (s *TransactionSplitStore) GetInvoiceDate() OptNilDateTime {
        return s.InvoiceDate
}

// SetType sets the value of Type.
func (s *TransactionSplitStore) SetType(val TransactionTypeProperty) {
        s.Type = val
}

// SetDate sets the value of Date.
func (s *TransactionSplitStore) SetDate(val time.Time) {
        s.Date = val
}

// SetAmount sets the value of Amount.
func (s *TransactionSplitStore) SetAmount(val string) {
        s.Amount = val
}

// SetDescription sets the value of Description.
func (s *TransactionSplitStore) SetDescription(val string) {
        s.Description = val
}

// SetOrder sets the value of Order.
func (s *TransactionSplitStore) SetOrder(val OptNilInt32) {
        s.Order = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *TransactionSplitStore) SetCurrencyID(val OptNilString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *TransactionSplitStore) SetCurrencyCode(val OptNilString) {
        s.CurrencyCode = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *TransactionSplitStore) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *TransactionSplitStore) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetForeignCurrencyCode sets the value of ForeignCurrencyCode.
func (s *TransactionSplitStore) SetForeignCurrencyCode(val OptNilString) {
        s.ForeignCurrencyCode = val
}

// SetBudgetID sets the value of BudgetID.
func (s *TransactionSplitStore) SetBudgetID(val OptNilString) {
        s.BudgetID = val
}

// SetBudgetName sets the value of BudgetName.
func (s *TransactionSplitStore) SetBudgetName(val OptNilString) {
        s.BudgetName = val
}

// SetCategoryID sets the value of CategoryID.
func (s *TransactionSplitStore) SetCategoryID(val OptNilString) {
        s.CategoryID = val
}

// SetCategoryName sets the value of CategoryName.
func (s *TransactionSplitStore) SetCategoryName(val OptNilString) {
        s.CategoryName = val
}

// SetSourceID sets the value of SourceID.
func (s *TransactionSplitStore) SetSourceID(val OptNilString) {
        s.SourceID = val
}

// SetSourceName sets the value of SourceName.
func (s *TransactionSplitStore) SetSourceName(val OptNilString) {
        s.SourceName = val
}

// SetDestinationID sets the value of DestinationID.
func (s *TransactionSplitStore) SetDestinationID(val OptNilString) {
        s.DestinationID = val
}

// SetDestinationName sets the value of DestinationName.
func (s *TransactionSplitStore) SetDestinationName(val OptNilString) {
        s.DestinationName = val
}

// SetReconciled sets the value of Reconciled.
func (s *TransactionSplitStore) SetReconciled(val OptBool) {
        s.Reconciled = val
}

// SetPiggyBankID sets the value of PiggyBankID.
func (s *TransactionSplitStore) SetPiggyBankID(val OptInt32) {
        s.PiggyBankID = val
}

// SetPiggyBankName sets the value of PiggyBankName.
func (s *TransactionSplitStore) SetPiggyBankName(val OptString) {
        s.PiggyBankName = val
}

// SetBillID sets the value of BillID.
func (s *TransactionSplitStore) SetBillID(val OptNilString) {
        s.BillID = val
}

// SetBillName sets the value of BillName.
func (s *TransactionSplitStore) SetBillName(val OptNilString) {
        s.BillName = val
}

// SetTags sets the value of Tags.
func (s *TransactionSplitStore) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetNotes sets the value of Notes.
func (s *TransactionSplitStore) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetInternalReference sets the value of InternalReference.
func (s *TransactionSplitStore) SetInternalReference(val OptNilString) {
        s.InternalReference = val
}

// SetExternalID sets the value of ExternalID.
func (s *TransactionSplitStore) SetExternalID(val OptNilString) {
        s.ExternalID = val
}

// SetExternalURL sets the value of ExternalURL.
func (s *TransactionSplitStore) SetExternalURL(val OptNilString) {
        s.ExternalURL = val
}

// SetBunqPaymentID sets the value of BunqPaymentID.
func (s *TransactionSplitStore) SetBunqPaymentID(val OptNilString) {
        s.BunqPaymentID = val
}

// SetSepaCc sets the value of SepaCc.
func (s *TransactionSplitStore) SetSepaCc(val OptNilString) {
        s.SepaCc = val
}

// SetSepaCtOp sets the value of SepaCtOp.
func (s *TransactionSplitStore) SetSepaCtOp(val OptNilString) {
        s.SepaCtOp = val
}

// SetSepaCtID sets the value of SepaCtID.
func (s *TransactionSplitStore) SetSepaCtID(val OptNilString) {
        s.SepaCtID = val
}

// SetSepaDb sets the value of SepaDb.
func (s *TransactionSplitStore) SetSepaDb(val OptNilString) {
        s.SepaDb = val
}

// SetSepaCountry sets the value of SepaCountry.
func (s *TransactionSplitStore) SetSepaCountry(val OptNilString) {
        s.SepaCountry = val
}

// SetSepaEp sets the value of SepaEp.
func (s *TransactionSplitStore) SetSepaEp(val OptNilString) {
        s.SepaEp = val
}

// SetSepaCi sets the value of SepaCi.
func (s *TransactionSplitStore) SetSepaCi(val OptNilString) {
        s.SepaCi = val
}

// SetSepaBatchID sets the value of SepaBatchID.
func (s *TransactionSplitStore) SetSepaBatchID(val OptNilString) {
        s.SepaBatchID = val
}

// SetInterestDate sets the value of InterestDate.
func (s *TransactionSplitStore) SetInterestDate(val OptNilDateTime) {
        s.InterestDate = val
}

// SetBookDate sets the value of BookDate.
func (s *TransactionSplitStore) SetBookDate(val OptNilDateTime) {
        s.BookDate = val
}

// SetProcessDate sets the value of ProcessDate.
func (s *TransactionSplitStore) SetProcessDate(val OptNilDateTime) {
        s.ProcessDate = val
}

// SetDueDate sets the value of DueDate.
func (s *TransactionSplitStore) SetDueDate(val OptNilDateTime) {
        s.DueDate = val
}

// SetPaymentDate sets the value of PaymentDate.
func (s *TransactionSplitStore) SetPaymentDate(val OptNilDateTime) {
        s.PaymentDate = val
}

// SetInvoiceDate sets the value of InvoiceDate.
func (s *TransactionSplitStore) SetInvoiceDate(val OptNilDateTime) {
        s.InvoiceDate = val
}

// Ref: #/components/schemas/TransactionSplitUpdate
type TransactionSplitUpdate struct {
        // Transaction journal ID of current transaction (split).
        TransactionJournalID OptString                  `json:"transaction_journal_id"`
        Type                 OptTransactionTypeProperty `json:"type"`
        // Date of the transaction.
        Date OptDateTime `json:"date"`
        // Amount of the transaction.
        Amount OptString `json:"amount"`
        // Description of the transaction.
        Description OptString `json:"description"`
        // Order of this entry in the list of transactions.
        Order OptNilInt32 `json:"order"`
        // Currency ID. Default is the source account's currency, or the user's default currency. Can be used
        // instead of currency_code.
        CurrencyID OptNilString `json:"currency_id"`
        // Currency code. Default is the source account's currency, or the user's default currency. Can be
        // used instead of currency_id.
        CurrencyCode   OptNilString `json:"currency_code"`
        CurrencySymbol OptString    `json:"currency_symbol"`
        CurrencyName   OptString    `json:"currency_name"`
        // Number of decimals used in this currency.
        CurrencyDecimalPlaces OptInt32 `json:"currency_decimal_places"`
        // The amount in a foreign currency.
        ForeignAmount OptNilString `json:"foreign_amount"`
        // Currency ID of the foreign currency. Default is null. Is required when you submit a foreign amount.
        ForeignCurrencyID OptNilString `json:"foreign_currency_id"`
        // Currency code of the foreign currency. Default is NULL. Can be used instead of the
        // foreign_currency_id, but this or the ID is required when submitting a foreign amount.
        ForeignCurrencyCode   OptNilString `json:"foreign_currency_code"`
        ForeignCurrencySymbol OptNilString `json:"foreign_currency_symbol"`
        // Number of decimals in the currency.
        ForeignCurrencyDecimalPlaces OptNilInt32 `json:"foreign_currency_decimal_places"`
        // The budget ID for this transaction.
        BudgetID OptNilString `json:"budget_id"`
        // The name of the budget to be used. If the budget name is unknown, the ID will be used or the value
        // will be ignored.
        BudgetName OptNilString `json:"budget_name"`
        // The category ID for this transaction.
        CategoryID OptNilString `json:"category_id"`
        // The name of the category to be used. If the category is unknown, it will be created. If the ID and
        // the name point to different categories, the ID overrules the name.
        CategoryName OptNilString `json:"category_name"`
        // ID of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account.
        SourceID OptNilString `json:"source_id"`
        // Name of the source account. For a withdrawal or a transfer, this must always be an asset account.
        // For deposits, this must be a revenue account. Can be used instead of the source_id. If the
        // transaction is a deposit, the source_name can be filled in freely: the account will be created
        // based on the name.
        SourceName OptNilString `json:"source_name"`
        SourceIban OptNilString `json:"source_iban"`
        // ID of the destination account. For a deposit or a transfer, this must always be an asset account.
        // For withdrawals this must be an expense account.
        DestinationID OptNilString `json:"destination_id"`
        // Name of the destination account. You can submit the name instead of the ID. For everything except
        // transfers, the account will be auto-generated if unknown, so submitting a name is enough.
        DestinationName OptNilString `json:"destination_name"`
        DestinationIban OptNilString `json:"destination_iban"`
        // If the transaction has been reconciled already. When you set this, the amount can no longer be
        // edited by the user.
        Reconciled OptBool `json:"reconciled"`
        // Optional. Use either this or the bill_name.
        BillID OptNilString `json:"bill_id"`
        // Optional. Use either this or the bill_id.
        BillName OptNilString `json:"bill_name"`
        // Array of tags.
        Tags  OptNilStringArray `json:"tags"`
        Notes OptNilString      `json:"notes"`
        // Reference to internal reference of other systems.
        InternalReference OptNilString `json:"internal_reference"`
        // Reference to external ID in other systems.
        ExternalID OptNilString `json:"external_id"`
        // External, custom URL for this transaction.
        ExternalURL OptNilString `json:"external_url"`
        // Internal ID of bunq transaction.
        BunqPaymentID OptNilString `json:"bunq_payment_id"`
        // SEPA Clearing Code.
        SepaCc OptNilString `json:"sepa_cc"`
        // SEPA Opposing Account Identifier.
        SepaCtOp OptNilString `json:"sepa_ct_op"`
        // SEPA end-to-end Identifier.
        SepaCtID OptNilString `json:"sepa_ct_id"`
        // SEPA mandate identifier.
        SepaDb OptNilString `json:"sepa_db"`
        // SEPA Country.
        SepaCountry OptNilString `json:"sepa_country"`
        // SEPA External Purpose indicator.
        SepaEp OptNilString `json:"sepa_ep"`
        // SEPA Creditor Identifier.
        SepaCi OptNilString `json:"sepa_ci"`
        // SEPA Batch ID.
        SepaBatchID  OptNilString   `json:"sepa_batch_id"`
        InterestDate OptNilDateTime `json:"interest_date"`
        BookDate     OptNilDateTime `json:"book_date"`
        ProcessDate  OptNilDateTime `json:"process_date"`
        DueDate      OptNilDateTime `json:"due_date"`
        PaymentDate  OptNilDateTime `json:"payment_date"`
        InvoiceDate  OptNilDateTime `json:"invoice_date"`
}

// GetTransactionJournalID returns the value of TransactionJournalID.
func (s *TransactionSplitUpdate) GetTransactionJournalID() OptString {
        return s.TransactionJournalID
}

// GetType returns the value of Type.
func (s *TransactionSplitUpdate) GetType() OptTransactionTypeProperty {
        return s.Type
}

// GetDate returns the value of Date.
func (s *TransactionSplitUpdate) GetDate() OptDateTime {
        return s.Date
}

// GetAmount returns the value of Amount.
func (s *TransactionSplitUpdate) GetAmount() OptString {
        return s.Amount
}

// GetDescription returns the value of Description.
func (s *TransactionSplitUpdate) GetDescription() OptString {
        return s.Description
}

// GetOrder returns the value of Order.
func (s *TransactionSplitUpdate) GetOrder() OptNilInt32 {
        return s.Order
}

// GetCurrencyID returns the value of CurrencyID.
func (s *TransactionSplitUpdate) GetCurrencyID() OptNilString {
        return s.CurrencyID
}

// GetCurrencyCode returns the value of CurrencyCode.
func (s *TransactionSplitUpdate) GetCurrencyCode() OptNilString {
        return s.CurrencyCode
}

// GetCurrencySymbol returns the value of CurrencySymbol.
func (s *TransactionSplitUpdate) GetCurrencySymbol() OptString {
        return s.CurrencySymbol
}

// GetCurrencyName returns the value of CurrencyName.
func (s *TransactionSplitUpdate) GetCurrencyName() OptString {
        return s.CurrencyName
}

// GetCurrencyDecimalPlaces returns the value of CurrencyDecimalPlaces.
func (s *TransactionSplitUpdate) GetCurrencyDecimalPlaces() OptInt32 {
        return s.CurrencyDecimalPlaces
}

// GetForeignAmount returns the value of ForeignAmount.
func (s *TransactionSplitUpdate) GetForeignAmount() OptNilString {
        return s.ForeignAmount
}

// GetForeignCurrencyID returns the value of ForeignCurrencyID.
func (s *TransactionSplitUpdate) GetForeignCurrencyID() OptNilString {
        return s.ForeignCurrencyID
}

// GetForeignCurrencyCode returns the value of ForeignCurrencyCode.
func (s *TransactionSplitUpdate) GetForeignCurrencyCode() OptNilString {
        return s.ForeignCurrencyCode
}

// GetForeignCurrencySymbol returns the value of ForeignCurrencySymbol.
func (s *TransactionSplitUpdate) GetForeignCurrencySymbol() OptNilString {
        return s.ForeignCurrencySymbol
}

// GetForeignCurrencyDecimalPlaces returns the value of ForeignCurrencyDecimalPlaces.
func (s *TransactionSplitUpdate) GetForeignCurrencyDecimalPlaces() OptNilInt32 {
        return s.ForeignCurrencyDecimalPlaces
}

// GetBudgetID returns the value of BudgetID.
func (s *TransactionSplitUpdate) GetBudgetID() OptNilString {
        return s.BudgetID
}

// GetBudgetName returns the value of BudgetName.
func (s *TransactionSplitUpdate) GetBudgetName() OptNilString {
        return s.BudgetName
}

// GetCategoryID returns the value of CategoryID.
func (s *TransactionSplitUpdate) GetCategoryID() OptNilString {
        return s.CategoryID
}

// GetCategoryName returns the value of CategoryName.
func (s *TransactionSplitUpdate) GetCategoryName() OptNilString {
        return s.CategoryName
}

// GetSourceID returns the value of SourceID.
func (s *TransactionSplitUpdate) GetSourceID() OptNilString {
        return s.SourceID
}

// GetSourceName returns the value of SourceName.
func (s *TransactionSplitUpdate) GetSourceName() OptNilString {
        return s.SourceName
}

// GetSourceIban returns the value of SourceIban.
func (s *TransactionSplitUpdate) GetSourceIban() OptNilString {
        return s.SourceIban
}

// GetDestinationID returns the value of DestinationID.
func (s *TransactionSplitUpdate) GetDestinationID() OptNilString {
        return s.DestinationID
}

// GetDestinationName returns the value of DestinationName.
func (s *TransactionSplitUpdate) GetDestinationName() OptNilString {
        return s.DestinationName
}

// GetDestinationIban returns the value of DestinationIban.
func (s *TransactionSplitUpdate) GetDestinationIban() OptNilString {
        return s.DestinationIban
}

// GetReconciled returns the value of Reconciled.
func (s *TransactionSplitUpdate) GetReconciled() OptBool {
        return s.Reconciled
}

// GetBillID returns the value of BillID.
func (s *TransactionSplitUpdate) GetBillID() OptNilString {
        return s.BillID
}

// GetBillName returns the value of BillName.
func (s *TransactionSplitUpdate) GetBillName() OptNilString {
        return s.BillName
}

// GetTags returns the value of Tags.
func (s *TransactionSplitUpdate) GetTags() OptNilStringArray {
        return s.Tags
}

// GetNotes returns the value of Notes.
func (s *TransactionSplitUpdate) GetNotes() OptNilString {
        return s.Notes
}

// GetInternalReference returns the value of InternalReference.
func (s *TransactionSplitUpdate) GetInternalReference() OptNilString {
        return s.InternalReference
}

// GetExternalID returns the value of ExternalID.
func (s *TransactionSplitUpdate) GetExternalID() OptNilString {
        return s.ExternalID
}

// GetExternalURL returns the value of ExternalURL.
func (s *TransactionSplitUpdate) GetExternalURL() OptNilString {
        return s.ExternalURL
}

// GetBunqPaymentID returns the value of BunqPaymentID.
func (s *TransactionSplitUpdate) GetBunqPaymentID() OptNilString {
        return s.BunqPaymentID
}

// GetSepaCc returns the value of SepaCc.
func (s *TransactionSplitUpdate) GetSepaCc() OptNilString {
        return s.SepaCc
}

// GetSepaCtOp returns the value of SepaCtOp.
func (s *TransactionSplitUpdate) GetSepaCtOp() OptNilString {
        return s.SepaCtOp
}

// GetSepaCtID returns the value of SepaCtID.
func (s *TransactionSplitUpdate) GetSepaCtID() OptNilString {
        return s.SepaCtID
}

// GetSepaDb returns the value of SepaDb.
func (s *TransactionSplitUpdate) GetSepaDb() OptNilString {
        return s.SepaDb
}

// GetSepaCountry returns the value of SepaCountry.
func (s *TransactionSplitUpdate) GetSepaCountry() OptNilString {
        return s.SepaCountry
}

// GetSepaEp returns the value of SepaEp.
func (s *TransactionSplitUpdate) GetSepaEp() OptNilString {
        return s.SepaEp
}

// GetSepaCi returns the value of SepaCi.
func (s *TransactionSplitUpdate) GetSepaCi() OptNilString {
        return s.SepaCi
}

// GetSepaBatchID returns the value of SepaBatchID.
func (s *TransactionSplitUpdate) GetSepaBatchID() OptNilString {
        return s.SepaBatchID
}

// GetInterestDate returns the value of InterestDate.
func (s *TransactionSplitUpdate) GetInterestDate() OptNilDateTime {
        return s.InterestDate
}

// GetBookDate returns the value of BookDate.
func (s *TransactionSplitUpdate) GetBookDate() OptNilDateTime {
        return s.BookDate
}

// GetProcessDate returns the value of ProcessDate.
func (s *TransactionSplitUpdate) GetProcessDate() OptNilDateTime {
        return s.ProcessDate
}

// GetDueDate returns the value of DueDate.
func (s *TransactionSplitUpdate) GetDueDate() OptNilDateTime {
        return s.DueDate
}

// GetPaymentDate returns the value of PaymentDate.
func (s *TransactionSplitUpdate) GetPaymentDate() OptNilDateTime {
        return s.PaymentDate
}

// GetInvoiceDate returns the value of InvoiceDate.
func (s *TransactionSplitUpdate) GetInvoiceDate() OptNilDateTime {
        return s.InvoiceDate
}

// SetTransactionJournalID sets the value of TransactionJournalID.
func (s *TransactionSplitUpdate) SetTransactionJournalID(val OptString) {
        s.TransactionJournalID = val
}

// SetType sets the value of Type.
func (s *TransactionSplitUpdate) SetType(val OptTransactionTypeProperty) {
        s.Type = val
}

// SetDate sets the value of Date.
func (s *TransactionSplitUpdate) SetDate(val OptDateTime) {
        s.Date = val
}

// SetAmount sets the value of Amount.
func (s *TransactionSplitUpdate) SetAmount(val OptString) {
        s.Amount = val
}

// SetDescription sets the value of Description.
func (s *TransactionSplitUpdate) SetDescription(val OptString) {
        s.Description = val
}

// SetOrder sets the value of Order.
func (s *TransactionSplitUpdate) SetOrder(val OptNilInt32) {
        s.Order = val
}

// SetCurrencyID sets the value of CurrencyID.
func (s *TransactionSplitUpdate) SetCurrencyID(val OptNilString) {
        s.CurrencyID = val
}

// SetCurrencyCode sets the value of CurrencyCode.
func (s *TransactionSplitUpdate) SetCurrencyCode(val OptNilString) {
        s.CurrencyCode = val
}

// SetCurrencySymbol sets the value of CurrencySymbol.
func (s *TransactionSplitUpdate) SetCurrencySymbol(val OptString) {
        s.CurrencySymbol = val
}

// SetCurrencyName sets the value of CurrencyName.
func (s *TransactionSplitUpdate) SetCurrencyName(val OptString) {
        s.CurrencyName = val
}

// SetCurrencyDecimalPlaces sets the value of CurrencyDecimalPlaces.
func (s *TransactionSplitUpdate) SetCurrencyDecimalPlaces(val OptInt32) {
        s.CurrencyDecimalPlaces = val
}

// SetForeignAmount sets the value of ForeignAmount.
func (s *TransactionSplitUpdate) SetForeignAmount(val OptNilString) {
        s.ForeignAmount = val
}

// SetForeignCurrencyID sets the value of ForeignCurrencyID.
func (s *TransactionSplitUpdate) SetForeignCurrencyID(val OptNilString) {
        s.ForeignCurrencyID = val
}

// SetForeignCurrencyCode sets the value of ForeignCurrencyCode.
func (s *TransactionSplitUpdate) SetForeignCurrencyCode(val OptNilString) {
        s.ForeignCurrencyCode = val
}

// SetForeignCurrencySymbol sets the value of ForeignCurrencySymbol.
func (s *TransactionSplitUpdate) SetForeignCurrencySymbol(val OptNilString) {
        s.ForeignCurrencySymbol = val
}

// SetForeignCurrencyDecimalPlaces sets the value of ForeignCurrencyDecimalPlaces.
func (s *TransactionSplitUpdate) SetForeignCurrencyDecimalPlaces(val OptNilInt32) {
        s.ForeignCurrencyDecimalPlaces = val
}

// SetBudgetID sets the value of BudgetID.
func (s *TransactionSplitUpdate) SetBudgetID(val OptNilString) {
        s.BudgetID = val
}

// SetBudgetName sets the value of BudgetName.
func (s *TransactionSplitUpdate) SetBudgetName(val OptNilString) {
        s.BudgetName = val
}

// SetCategoryID sets the value of CategoryID.
func (s *TransactionSplitUpdate) SetCategoryID(val OptNilString) {
        s.CategoryID = val
}

// SetCategoryName sets the value of CategoryName.
func (s *TransactionSplitUpdate) SetCategoryName(val OptNilString) {
        s.CategoryName = val
}

// SetSourceID sets the value of SourceID.
func (s *TransactionSplitUpdate) SetSourceID(val OptNilString) {
        s.SourceID = val
}

// SetSourceName sets the value of SourceName.
func (s *TransactionSplitUpdate) SetSourceName(val OptNilString) {
        s.SourceName = val
}

// SetSourceIban sets the value of SourceIban.
func (s *TransactionSplitUpdate) SetSourceIban(val OptNilString) {
        s.SourceIban = val
}

// SetDestinationID sets the value of DestinationID.
func (s *TransactionSplitUpdate) SetDestinationID(val OptNilString) {
        s.DestinationID = val
}

// SetDestinationName sets the value of DestinationName.
func (s *TransactionSplitUpdate) SetDestinationName(val OptNilString) {
        s.DestinationName = val
}

// SetDestinationIban sets the value of DestinationIban.
func (s *TransactionSplitUpdate) SetDestinationIban(val OptNilString) {
        s.DestinationIban = val
}

// SetReconciled sets the value of Reconciled.
func (s *TransactionSplitUpdate) SetReconciled(val OptBool) {
        s.Reconciled = val
}

// SetBillID sets the value of BillID.
func (s *TransactionSplitUpdate) SetBillID(val OptNilString) {
        s.BillID = val
}

// SetBillName sets the value of BillName.
func (s *TransactionSplitUpdate) SetBillName(val OptNilString) {
        s.BillName = val
}

// SetTags sets the value of Tags.
func (s *TransactionSplitUpdate) SetTags(val OptNilStringArray) {
        s.Tags = val
}

// SetNotes sets the value of Notes.
func (s *TransactionSplitUpdate) SetNotes(val OptNilString) {
        s.Notes = val
}

// SetInternalReference sets the value of InternalReference.
func (s *TransactionSplitUpdate) SetInternalReference(val OptNilString) {
        s.InternalReference = val
}

// SetExternalID sets the value of ExternalID.
func (s *TransactionSplitUpdate) SetExternalID(val OptNilString) {
        s.ExternalID = val
}

// SetExternalURL sets the value of ExternalURL.
func (s *TransactionSplitUpdate) SetExternalURL(val OptNilString) {
        s.ExternalURL = val
}

// SetBunqPaymentID sets the value of BunqPaymentID.
func (s *TransactionSplitUpdate) SetBunqPaymentID(val OptNilString) {
        s.BunqPaymentID = val
}

// SetSepaCc sets the value of SepaCc.
func (s *TransactionSplitUpdate) SetSepaCc(val OptNilString) {
        s.SepaCc = val
}

// SetSepaCtOp sets the value of SepaCtOp.
func (s *TransactionSplitUpdate) SetSepaCtOp(val OptNilString) {
        s.SepaCtOp = val
}

// SetSepaCtID sets the value of SepaCtID.
func (s *TransactionSplitUpdate) SetSepaCtID(val OptNilString) {
        s.SepaCtID = val
}

// SetSepaDb sets the value of SepaDb.
func (s *TransactionSplitUpdate) SetSepaDb(val OptNilString) {
        s.SepaDb = val
}

// SetSepaCountry sets the value of SepaCountry.
func (s *TransactionSplitUpdate) SetSepaCountry(val OptNilString) {
        s.SepaCountry = val
}

// SetSepaEp sets the value of SepaEp.
func (s *TransactionSplitUpdate) SetSepaEp(val OptNilString) {
        s.SepaEp = val
}

// SetSepaCi sets the value of SepaCi.
func (s *TransactionSplitUpdate) SetSepaCi(val OptNilString) {
        s.SepaCi = val
}

// SetSepaBatchID sets the value of SepaBatchID.
func (s *TransactionSplitUpdate) SetSepaBatchID(val OptNilString) {
        s.SepaBatchID = val
}

// SetInterestDate sets the value of InterestDate.
func (s *TransactionSplitUpdate) SetInterestDate(val OptNilDateTime) {
        s.InterestDate = val
}

// SetBookDate sets the value of BookDate.
func (s *TransactionSplitUpdate) SetBookDate(val OptNilDateTime) {
        s.BookDate = val
}

// SetProcessDate sets the value of ProcessDate.
func (s *TransactionSplitUpdate) SetProcessDate(val OptNilDateTime) {
        s.ProcessDate = val
}

// SetDueDate sets the value of DueDate.
func (s *TransactionSplitUpdate) SetDueDate(val OptNilDateTime) {
        s.DueDate = val
}

// SetPaymentDate sets the value of PaymentDate.
func (s *TransactionSplitUpdate) SetPaymentDate(val OptNilDateTime) {
        s.PaymentDate = val
}

// SetInvoiceDate sets the value of InvoiceDate.
func (s *TransactionSplitUpdate) SetInvoiceDate(val OptNilDateTime) {
        s.InvoiceDate = val
}

// Ref: #/components/schemas/TransactionStore
type TransactionStore struct {
        // Break if the submitted transaction exists already.
        ErrorIfDuplicateHash OptBool `json:"error_if_duplicate_hash"`
        // Whether or not to apply rules when submitting transaction.
        ApplyRules OptBool `json:"apply_rules"`
        // Whether or not to fire the webhooks that are related to this event.
        FireWebhooks OptBool `json:"fire_webhooks"`
        // Title of the transaction if it has been split in more than one piece. Empty otherwise.
        GroupTitle   OptNilString            `json:"group_title"`
        Transactions []TransactionSplitStore `json:"transactions"`
}

// GetErrorIfDuplicateHash returns the value of ErrorIfDuplicateHash.
func (s *TransactionStore) GetErrorIfDuplicateHash() OptBool {
        return s.ErrorIfDuplicateHash
}

// GetApplyRules returns the value of ApplyRules.
func (s *TransactionStore) GetApplyRules() OptBool {
        return s.ApplyRules
}

// GetFireWebhooks returns the value of FireWebhooks.
func (s *TransactionStore) GetFireWebhooks() OptBool {
        return s.FireWebhooks
}

// GetGroupTitle returns the value of GroupTitle.
func (s *TransactionStore) GetGroupTitle() OptNilString {
        return s.GroupTitle
}

// GetTransactions returns the value of Transactions.
func (s *TransactionStore) GetTransactions() []TransactionSplitStore {
        return s.Transactions
}

// SetErrorIfDuplicateHash sets the value of ErrorIfDuplicateHash.
func (s *TransactionStore) SetErrorIfDuplicateHash(val OptBool) {
        s.ErrorIfDuplicateHash = val
}

// SetApplyRules sets the value of ApplyRules.
func (s *TransactionStore) SetApplyRules(val OptBool) {
        s.ApplyRules = val
}

// SetFireWebhooks sets the value of FireWebhooks.
func (s *TransactionStore) SetFireWebhooks(val OptBool) {
        s.FireWebhooks = val
}

// SetGroupTitle sets the value of GroupTitle.
func (s *TransactionStore) SetGroupTitle(val OptNilString) {
        s.GroupTitle = val
}

// SetTransactions sets the value of Transactions.
func (s *TransactionStore) SetTransactions(val []TransactionSplitStore) {
        s.Transactions = val
}

// Ref: #/components/schemas/TransactionTypeFilter
type TransactionTypeFilter string

const (
        TransactionTypeFilterAll            TransactionTypeFilter = "all"
        TransactionTypeFilterWithdrawal     TransactionTypeFilter = "withdrawal"
        TransactionTypeFilterWithdrawals    TransactionTypeFilter = "withdrawals"
        TransactionTypeFilterExpense        TransactionTypeFilter = "expense"
        TransactionTypeFilterDeposit        TransactionTypeFilter = "deposit"
        TransactionTypeFilterDeposits       TransactionTypeFilter = "deposits"
        TransactionTypeFilterIncome         TransactionTypeFilter = "income"
        TransactionTypeFilterTransfer       TransactionTypeFilter = "transfer"
        TransactionTypeFilterTransfers      TransactionTypeFilter = "transfers"
        TransactionTypeFilterOpeningBalance TransactionTypeFilter = "opening_balance"
        TransactionTypeFilterReconciliation TransactionTypeFilter = "reconciliation"
        TransactionTypeFilterSpecial        TransactionTypeFilter = "special"
        TransactionTypeFilterSpecials       TransactionTypeFilter = "specials"
        TransactionTypeFilterDefault        TransactionTypeFilter = "default"
)

// AllValues returns all TransactionTypeFilter values.
func (TransactionTypeFilter) AllValues() []TransactionTypeFilter {
        return []TransactionTypeFilter{
                TransactionTypeFilterAll,
                TransactionTypeFilterWithdrawal,
                TransactionTypeFilterWithdrawals,
                TransactionTypeFilterExpense,
                TransactionTypeFilterDeposit,
                TransactionTypeFilterDeposits,
                TransactionTypeFilterIncome,
                TransactionTypeFilterTransfer,
                TransactionTypeFilterTransfers,
                TransactionTypeFilterOpeningBalance,
                TransactionTypeFilterReconciliation,
                TransactionTypeFilterSpecial,
                TransactionTypeFilterSpecials,
                TransactionTypeFilterDefault,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s TransactionTypeFilter) MarshalText() ([]byte, error) {
        switch s {
        case TransactionTypeFilterAll:
                return []byte(s), nil
        case TransactionTypeFilterWithdrawal:
                return []byte(s), nil
        case TransactionTypeFilterWithdrawals:
                return []byte(s), nil
        case TransactionTypeFilterExpense:
                return []byte(s), nil
        case TransactionTypeFilterDeposit:
                return []byte(s), nil
        case TransactionTypeFilterDeposits:
                return []byte(s), nil
        case TransactionTypeFilterIncome:
                return []byte(s), nil
        case TransactionTypeFilterTransfer:
                return []byte(s), nil
        case TransactionTypeFilterTransfers:
                return []byte(s), nil
        case TransactionTypeFilterOpeningBalance:
                return []byte(s), nil
        case TransactionTypeFilterReconciliation:
                return []byte(s), nil
        case TransactionTypeFilterSpecial:
                return []byte(s), nil
        case TransactionTypeFilterSpecials:
                return []byte(s), nil
        case TransactionTypeFilterDefault:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *TransactionTypeFilter) UnmarshalText(data []byte) error {
        switch TransactionTypeFilter(data) {
        case TransactionTypeFilterAll:
                *s = TransactionTypeFilterAll
                return nil
        case TransactionTypeFilterWithdrawal:
                *s = TransactionTypeFilterWithdrawal
                return nil
        case TransactionTypeFilterWithdrawals:
                *s = TransactionTypeFilterWithdrawals
                return nil
        case TransactionTypeFilterExpense:
                *s = TransactionTypeFilterExpense
                return nil
        case TransactionTypeFilterDeposit:
                *s = TransactionTypeFilterDeposit
                return nil
        case TransactionTypeFilterDeposits:
                *s = TransactionTypeFilterDeposits
                return nil
        case TransactionTypeFilterIncome:
                *s = TransactionTypeFilterIncome
                return nil
        case TransactionTypeFilterTransfer:
                *s = TransactionTypeFilterTransfer
                return nil
        case TransactionTypeFilterTransfers:
                *s = TransactionTypeFilterTransfers
                return nil
        case TransactionTypeFilterOpeningBalance:
                *s = TransactionTypeFilterOpeningBalance
                return nil
        case TransactionTypeFilterReconciliation:
                *s = TransactionTypeFilterReconciliation
                return nil
        case TransactionTypeFilterSpecial:
                *s = TransactionTypeFilterSpecial
                return nil
        case TransactionTypeFilterSpecials:
                *s = TransactionTypeFilterSpecials
                return nil
        case TransactionTypeFilterDefault:
                *s = TransactionTypeFilterDefault
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/TransactionTypeProperty
type TransactionTypeProperty string

const (
        TransactionTypePropertyWithdrawal     TransactionTypeProperty = "withdrawal"
        TransactionTypePropertyDeposit        TransactionTypeProperty = "deposit"
        TransactionTypePropertyTransfer       TransactionTypeProperty = "transfer"
        TransactionTypePropertyReconciliation TransactionTypeProperty = "reconciliation"
        TransactionTypePropertyOpeningBalance TransactionTypeProperty = "opening balance"
)

// AllValues returns all TransactionTypeProperty values.
func (TransactionTypeProperty) AllValues() []TransactionTypeProperty {
        return []TransactionTypeProperty{
                TransactionTypePropertyWithdrawal,
                TransactionTypePropertyDeposit,
                TransactionTypePropertyTransfer,
                TransactionTypePropertyReconciliation,
                TransactionTypePropertyOpeningBalance,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s TransactionTypeProperty) MarshalText() ([]byte, error) {
        switch s {
        case TransactionTypePropertyWithdrawal:
                return []byte(s), nil
        case TransactionTypePropertyDeposit:
                return []byte(s), nil
        case TransactionTypePropertyTransfer:
                return []byte(s), nil
        case TransactionTypePropertyReconciliation:
                return []byte(s), nil
        case TransactionTypePropertyOpeningBalance:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *TransactionTypeProperty) UnmarshalText(data []byte) error {
        switch TransactionTypeProperty(data) {
        case TransactionTypePropertyWithdrawal:
                *s = TransactionTypePropertyWithdrawal
                return nil
        case TransactionTypePropertyDeposit:
                *s = TransactionTypePropertyDeposit
                return nil
        case TransactionTypePropertyTransfer:
                *s = TransactionTypePropertyTransfer
                return nil
        case TransactionTypePropertyReconciliation:
                *s = TransactionTypePropertyReconciliation
                return nil
        case TransactionTypePropertyOpeningBalance:
                *s = TransactionTypePropertyOpeningBalance
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/TransactionUpdate
type TransactionUpdate struct {
        // Whether or not to apply rules when submitting transaction.
        ApplyRules OptBool `json:"apply_rules"`
        // Whether or not to fire the webhooks that are related to this event.
        FireWebhooks OptBool `json:"fire_webhooks"`
        // Title of the transaction if it has been split in more than one piece. Empty otherwise.
        GroupTitle   OptNilString             `json:"group_title"`
        Transactions []TransactionSplitUpdate `json:"transactions"`
}

// GetApplyRules returns the value of ApplyRules.
func (s *TransactionUpdate) GetApplyRules() OptBool {
        return s.ApplyRules
}

// GetFireWebhooks returns the value of FireWebhooks.
func (s *TransactionUpdate) GetFireWebhooks() OptBool {
        return s.FireWebhooks
}

// GetGroupTitle returns the value of GroupTitle.
func (s *TransactionUpdate) GetGroupTitle() OptNilString {
        return s.GroupTitle
}

// GetTransactions returns the value of Transactions.
func (s *TransactionUpdate) GetTransactions() []TransactionSplitUpdate {
        return s.Transactions
}

// SetApplyRules sets the value of ApplyRules.
func (s *TransactionUpdate) SetApplyRules(val OptBool) {
        s.ApplyRules = val
}

// SetFireWebhooks sets the value of FireWebhooks.
func (s *TransactionUpdate) SetFireWebhooks(val OptBool) {
        s.FireWebhooks = val
}

// SetGroupTitle sets the value of GroupTitle.
func (s *TransactionUpdate) SetGroupTitle(val OptNilString) {
        s.GroupTitle = val
}

// SetTransactions sets the value of Transactions.
func (s *TransactionUpdate) SetTransactions(val []TransactionSplitUpdate) {
        s.Transactions = val
}

// Ref: #/components/schemas/Unauthenticated
type Unauthenticated struct {
        Message   OptString `json:"message"`
        Exception OptString `json:"exception"`
}

// GetMessage returns the value of Message.
func (s *Unauthenticated) GetMessage() OptString {
        return s.Message
}

// GetException returns the value of Exception.
func (s *Unauthenticated) GetException() OptString {
        return s.Exception
}

// SetMessage sets the value of Message.
func (s *Unauthenticated) SetMessage(val OptString) {
        s.Message = val
}

// SetException sets the value of Exception.
func (s *Unauthenticated) SetException(val OptString) {
        s.Exception = val
}

func (*Unauthenticated) bulkUpdateTransactionsRes()         {}
func (*Unauthenticated) defaultCurrencyRes()                {}
func (*Unauthenticated) deleteAccountRes()                  {}
func (*Unauthenticated) deleteAttachmentRes()               {}
func (*Unauthenticated) deleteBillRes()                     {}
func (*Unauthenticated) deleteBudgetLimitRes()              {}
func (*Unauthenticated) deleteBudgetRes()                   {}
func (*Unauthenticated) deleteCategoryRes()                 {}
func (*Unauthenticated) deleteCurrencyRes()                 {}
func (*Unauthenticated) deleteLinkTypeRes()                 {}
func (*Unauthenticated) deleteObjectGroupRes()              {}
func (*Unauthenticated) deletePiggyBankRes()                {}
func (*Unauthenticated) deleteRecurrenceRes()               {}
func (*Unauthenticated) deleteRuleGroupRes()                {}
func (*Unauthenticated) deleteRuleRes()                     {}
func (*Unauthenticated) deleteTagRes()                      {}
func (*Unauthenticated) deleteTransactionJournalRes()       {}
func (*Unauthenticated) deleteTransactionLinkRes()          {}
func (*Unauthenticated) deleteTransactionRes()              {}
func (*Unauthenticated) deleteUserRes()                     {}
func (*Unauthenticated) deleteWebhookMessageAttemptRes()    {}
func (*Unauthenticated) deleteWebhookMessageRes()           {}
func (*Unauthenticated) deleteWebhookRes()                  {}
func (*Unauthenticated) destroyDataRes()                    {}
func (*Unauthenticated) disableCurrencyRes()                {}
func (*Unauthenticated) downloadAttachmentRes()             {}
func (*Unauthenticated) enableCurrencyRes()                 {}
func (*Unauthenticated) exportAccountsRes()                 {}
func (*Unauthenticated) exportBillsRes()                    {}
func (*Unauthenticated) exportBudgetsRes()                  {}
func (*Unauthenticated) exportCategoriesRes()               {}
func (*Unauthenticated) exportPiggiesRes()                  {}
func (*Unauthenticated) exportRecurringRes()                {}
func (*Unauthenticated) exportRulesRes()                    {}
func (*Unauthenticated) exportTagsRes()                     {}
func (*Unauthenticated) exportTransactionsRes()             {}
func (*Unauthenticated) fireRuleGroupRes()                  {}
func (*Unauthenticated) fireRuleRes()                       {}
func (*Unauthenticated) getAboutRes()                       {}
func (*Unauthenticated) getAccountRes()                     {}
func (*Unauthenticated) getAccountsACRes()                  {}
func (*Unauthenticated) getAttachmentRes()                  {}
func (*Unauthenticated) getAvailableBudgetRes()             {}
func (*Unauthenticated) getBasicSummaryRes()                {}
func (*Unauthenticated) getBillRes()                        {}
func (*Unauthenticated) getBillsACRes()                     {}
func (*Unauthenticated) getBudgetLimitRes()                 {}
func (*Unauthenticated) getBudgetRes()                      {}
func (*Unauthenticated) getBudgetsACRes()                   {}
func (*Unauthenticated) getCategoriesACRes()                {}
func (*Unauthenticated) getCategoryRes()                    {}
func (*Unauthenticated) getChartAccountOverviewRes()        {}
func (*Unauthenticated) getConfigurationRes()               {}
func (*Unauthenticated) getCronRes()                        {}
func (*Unauthenticated) getCurrenciesACRes()                {}
func (*Unauthenticated) getCurrenciesCodeACRes()            {}
func (*Unauthenticated) getCurrencyRes()                    {}
func (*Unauthenticated) getCurrentUserRes()                 {}
func (*Unauthenticated) getDefaultCurrencyRes()             {}
func (*Unauthenticated) getLinkTypeRes()                    {}
func (*Unauthenticated) getObjectGroupRes()                 {}
func (*Unauthenticated) getObjectGroupsACRes()              {}
func (*Unauthenticated) getPiggiesACRes()                   {}
func (*Unauthenticated) getPiggiesBalanceACRes()            {}
func (*Unauthenticated) getPiggyBankRes()                   {}
func (*Unauthenticated) getPreferenceRes()                  {}
func (*Unauthenticated) getRecurrenceRes()                  {}
func (*Unauthenticated) getRecurringACRes()                 {}
func (*Unauthenticated) getRuleGroupRes()                   {}
func (*Unauthenticated) getRuleGroupsACRes()                {}
func (*Unauthenticated) getRuleRes()                        {}
func (*Unauthenticated) getRulesACRes()                     {}
func (*Unauthenticated) getSingleConfigurationRes()         {}
func (*Unauthenticated) getSingleWebhookMessageAttemptRes() {}
func (*Unauthenticated) getSingleWebhookMessageRes()        {}
func (*Unauthenticated) getTagACRes()                       {}
func (*Unauthenticated) getTagRes()                         {}
func (*Unauthenticated) getTransactionByJournalRes()        {}
func (*Unauthenticated) getTransactionLinkRes()             {}
func (*Unauthenticated) getTransactionRes()                 {}
func (*Unauthenticated) getTransactionTypesACRes()          {}
func (*Unauthenticated) getTransactionsACRes()              {}
func (*Unauthenticated) getTransactionsIDACRes()            {}
func (*Unauthenticated) getUserRes()                        {}
func (*Unauthenticated) getWebhookMessageAttemptsRes()      {}
func (*Unauthenticated) getWebhookMessagesRes()             {}
func (*Unauthenticated) getWebhookRes()                     {}
func (*Unauthenticated) insightExpenseAssetRes()            {}
func (*Unauthenticated) insightExpenseBillRes()             {}
func (*Unauthenticated) insightExpenseBudgetRes()           {}
func (*Unauthenticated) insightExpenseCategoryRes()         {}
func (*Unauthenticated) insightExpenseExpenseRes()          {}
func (*Unauthenticated) insightExpenseNoBillRes()           {}
func (*Unauthenticated) insightExpenseNoBudgetRes()         {}
func (*Unauthenticated) insightExpenseNoCategoryRes()       {}
func (*Unauthenticated) insightExpenseNoTagRes()            {}
func (*Unauthenticated) insightExpenseTagRes()              {}
func (*Unauthenticated) insightExpenseTotalRes()            {}
func (*Unauthenticated) insightIncomeAssetRes()             {}
func (*Unauthenticated) insightIncomeCategoryRes()          {}
func (*Unauthenticated) insightIncomeNoCategoryRes()        {}
func (*Unauthenticated) insightIncomeNoTagRes()             {}
func (*Unauthenticated) insightIncomeRevenueRes()           {}
func (*Unauthenticated) insightIncomeTagRes()               {}
func (*Unauthenticated) insightIncomeTotalRes()             {}
func (*Unauthenticated) insightTransferCategoryRes()        {}
func (*Unauthenticated) insightTransferNoCategoryRes()      {}
func (*Unauthenticated) insightTransferNoTagRes()           {}
func (*Unauthenticated) insightTransferTagRes()             {}
func (*Unauthenticated) insightTransferTotalRes()           {}
func (*Unauthenticated) insightTransfersRes()               {}
func (*Unauthenticated) listAccountByCurrencyRes()          {}
func (*Unauthenticated) listAccountRes()                    {}
func (*Unauthenticated) listAttachmentByAccountRes()        {}
func (*Unauthenticated) listAttachmentByBillRes()           {}
func (*Unauthenticated) listAttachmentByBudgetRes()         {}
func (*Unauthenticated) listAttachmentByCategoryRes()       {}
func (*Unauthenticated) listAttachmentByPiggyBankRes()      {}
func (*Unauthenticated) listAttachmentByTagRes()            {}
func (*Unauthenticated) listAttachmentByTransactionRes()    {}
func (*Unauthenticated) listAttachmentRes()                 {}
func (*Unauthenticated) listAvailableBudgetByCurrencyRes()  {}
func (*Unauthenticated) listAvailableBudgetRes()            {}
func (*Unauthenticated) listBillByCurrencyRes()             {}
func (*Unauthenticated) listBillByObjectGroupRes()          {}
func (*Unauthenticated) listBillRes()                       {}
func (*Unauthenticated) listBudgetLimitByBudgetRes()        {}
func (*Unauthenticated) listBudgetLimitByCurrencyRes()      {}
func (*Unauthenticated) listBudgetLimitRes()                {}
func (*Unauthenticated) listBudgetRes()                     {}
func (*Unauthenticated) listCategoryRes()                   {}
func (*Unauthenticated) listCurrencyRes()                   {}
func (*Unauthenticated) listEventByPiggyBankRes()           {}
func (*Unauthenticated) listEventByTransactionRes()         {}
func (*Unauthenticated) listLinkTypeRes()                   {}
func (*Unauthenticated) listLinksByJournalRes()             {}
func (*Unauthenticated) listObjectGroupsRes()               {}
func (*Unauthenticated) listPiggyBankByAccountRes()         {}
func (*Unauthenticated) listPiggyBankByObjectGroupRes()     {}
func (*Unauthenticated) listPiggyBankRes()                  {}
func (*Unauthenticated) listPreferenceRes()                 {}
func (*Unauthenticated) listRecurrenceByCurrencyRes()       {}
func (*Unauthenticated) listRecurrenceRes()                 {}
func (*Unauthenticated) listRuleByBillRes()                 {}
func (*Unauthenticated) listRuleByCurrencyRes()             {}
func (*Unauthenticated) listRuleByGroupRes()                {}
func (*Unauthenticated) listRuleGroupRes()                  {}
func (*Unauthenticated) listRuleRes()                       {}
func (*Unauthenticated) listTagRes()                        {}
func (*Unauthenticated) listTransactionByAccountRes()       {}
func (*Unauthenticated) listTransactionByBillRes()          {}
func (*Unauthenticated) listTransactionByBudgetLimitRes()   {}
func (*Unauthenticated) listTransactionByBudgetRes()        {}
func (*Unauthenticated) listTransactionByCategoryRes()      {}
func (*Unauthenticated) listTransactionByCurrencyRes()      {}
func (*Unauthenticated) listTransactionByLinkTypeRes()      {}
func (*Unauthenticated) listTransactionByRecurrenceRes()    {}
func (*Unauthenticated) listTransactionByTagRes()           {}
func (*Unauthenticated) listTransactionLinkRes()            {}
func (*Unauthenticated) listTransactionRes()                {}
func (*Unauthenticated) listUserRes()                       {}
func (*Unauthenticated) listWebhookRes()                    {}
func (*Unauthenticated) purgeDataRes()                      {}
func (*Unauthenticated) searchAccountsRes()                 {}
func (*Unauthenticated) searchTransactionsRes()             {}
func (*Unauthenticated) setConfigurationRes()               {}
func (*Unauthenticated) storeAccountRes()                   {}
func (*Unauthenticated) storeAttachmentRes()                {}
func (*Unauthenticated) storeBillRes()                      {}
func (*Unauthenticated) storeBudgetLimitRes()               {}
func (*Unauthenticated) storeBudgetRes()                    {}
func (*Unauthenticated) storeCategoryRes()                  {}
func (*Unauthenticated) storeCurrencyRes()                  {}
func (*Unauthenticated) storeLinkTypeRes()                  {}
func (*Unauthenticated) storePiggyBankRes()                 {}
func (*Unauthenticated) storePreferenceRes()                {}
func (*Unauthenticated) storeRecurrenceRes()                {}
func (*Unauthenticated) storeRuleGroupRes()                 {}
func (*Unauthenticated) storeRuleRes()                      {}
func (*Unauthenticated) storeTagRes()                       {}
func (*Unauthenticated) storeTransactionLinkRes()           {}
func (*Unauthenticated) storeTransactionRes()               {}
func (*Unauthenticated) storeUserRes()                      {}
func (*Unauthenticated) storeWebhookRes()                   {}
func (*Unauthenticated) testRuleGroupRes()                  {}
func (*Unauthenticated) testRuleRes()                       {}
func (*Unauthenticated) updateAccountRes()                  {}
func (*Unauthenticated) updateAttachmentRes()               {}
func (*Unauthenticated) updateBillRes()                     {}
func (*Unauthenticated) updateBudgetLimitRes()              {}
func (*Unauthenticated) updateBudgetRes()                   {}
func (*Unauthenticated) updateCategoryRes()                 {}
func (*Unauthenticated) updateCurrencyRes()                 {}
func (*Unauthenticated) updateLinkTypeRes()                 {}
func (*Unauthenticated) updateObjectGroupRes()              {}
func (*Unauthenticated) updatePiggyBankRes()                {}
func (*Unauthenticated) updatePreferenceRes()               {}
func (*Unauthenticated) updateRecurrenceRes()               {}
func (*Unauthenticated) updateRuleGroupRes()                {}
func (*Unauthenticated) updateRuleRes()                     {}
func (*Unauthenticated) updateTagRes()                      {}
func (*Unauthenticated) updateTransactionLinkRes()          {}
func (*Unauthenticated) updateTransactionRes()              {}
func (*Unauthenticated) updateUserRes()                     {}
func (*Unauthenticated) updateWebhookRes()                  {}
func (*Unauthenticated) uploadAttachmentRes()               {}

// UploadAttachmentNoContent is response for UploadAttachment operation.
type UploadAttachmentNoContent struct{}

func (*UploadAttachmentNoContent) uploadAttachmentRes() {}

type UploadAttachmentReq struct {
        Data io.Reader
}

// Read reads data from the Data reader.
//
// Kept to satisfy the io.Reader interface.
func (s UploadAttachmentReq) Read(p []byte) (n int, err error) {
        if s.Data == nil {
                return 0, io.EOF
        }
        return s.Data.Read(p)
}

// Ref: #/components/schemas/User
type User struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // The new users email address.
        Email string `json:"email"`
        // Boolean to indicate if the user is blocked.
        Blocked     OptBool                       `json:"blocked"`
        BlockedCode OptNilUserBlockedCodeProperty `json:"blocked_code"`
        Role        OptNilUserRoleProperty        `json:"role"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *User) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *User) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetEmail returns the value of Email.
func (s *User) GetEmail() string {
        return s.Email
}

// GetBlocked returns the value of Blocked.
func (s *User) GetBlocked() OptBool {
        return s.Blocked
}

// GetBlockedCode returns the value of BlockedCode.
func (s *User) GetBlockedCode() OptNilUserBlockedCodeProperty {
        return s.BlockedCode
}

// GetRole returns the value of Role.
func (s *User) GetRole() OptNilUserRoleProperty {
        return s.Role
}

// SetCreatedAt sets the value of CreatedAt.
func (s *User) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *User) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetEmail sets the value of Email.
func (s *User) SetEmail(val string) {
        s.Email = val
}

// SetBlocked sets the value of Blocked.
func (s *User) SetBlocked(val OptBool) {
        s.Blocked = val
}

// SetBlockedCode sets the value of BlockedCode.
func (s *User) SetBlockedCode(val OptNilUserBlockedCodeProperty) {
        s.BlockedCode = val
}

// SetRole sets the value of Role.
func (s *User) SetRole(val OptNilUserRoleProperty) {
        s.Role = val
}

// Ref: #/components/schemas/UserArray
type UserArray struct {
        Data  []UserRead `json:"data"`
        Meta  Meta       `json:"meta"`
        Links PageLink   `json:"links"`
}

// GetData returns the value of Data.
func (s *UserArray) GetData() []UserRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *UserArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *UserArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *UserArray) SetData(val []UserRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *UserArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *UserArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*UserArray) listUserRes() {}

// If you say the user must be blocked, this will be the reason code.
// Ref: #/components/schemas/UserBlockedCodeProperty
type UserBlockedCodeProperty string

const (
        UserBlockedCodePropertyEmailChanged UserBlockedCodeProperty = "email_changed"
)

// AllValues returns all UserBlockedCodeProperty values.
func (UserBlockedCodeProperty) AllValues() []UserBlockedCodeProperty {
        return []UserBlockedCodeProperty{
                UserBlockedCodePropertyEmailChanged,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s UserBlockedCodeProperty) MarshalText() ([]byte, error) {
        switch s {
        case UserBlockedCodePropertyEmailChanged:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *UserBlockedCodeProperty) UnmarshalText(data []byte) error {
        switch UserBlockedCodeProperty(data) {
        case UserBlockedCodePropertyEmailChanged:
                *s = UserBlockedCodePropertyEmailChanged
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/UserRead
type UserRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes User       `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *UserRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *UserRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *UserRead) GetAttributes() User {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *UserRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *UserRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *UserRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *UserRead) SetAttributes(val User) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *UserRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Role for the user. Can be empty or omitted.
// Ref: #/components/schemas/UserRoleProperty
type UserRoleProperty string

const (
        UserRolePropertyOwner UserRoleProperty = "owner"
        UserRolePropertyDemo  UserRoleProperty = "demo"
)

// AllValues returns all UserRoleProperty values.
func (UserRoleProperty) AllValues() []UserRoleProperty {
        return []UserRoleProperty{
                UserRolePropertyOwner,
                UserRolePropertyDemo,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s UserRoleProperty) MarshalText() ([]byte, error) {
        switch s {
        case UserRolePropertyOwner:
                return []byte(s), nil
        case UserRolePropertyDemo:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *UserRoleProperty) UnmarshalText(data []byte) error {
        switch UserRoleProperty(data) {
        case UserRolePropertyOwner:
                *s = UserRolePropertyOwner
                return nil
        case UserRolePropertyDemo:
                *s = UserRolePropertyDemo
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/UserSingle
type UserSingle struct {
        Data UserRead `json:"data"`
}

// GetData returns the value of Data.
func (s *UserSingle) GetData() UserRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *UserSingle) SetData(val UserRead) {
        s.Data = val
}

func (*UserSingle) getCurrentUserRes() {}
func (*UserSingle) getUserRes()        {}
func (*UserSingle) storeUserRes()      {}
func (*UserSingle) updateUserRes()     {}

// Ref: #/components/schemas/ValidationError
type ValidationError struct {
        Message OptString                `json:"message"`
        Errors  OptValidationErrorErrors `json:"errors"`
}

// GetMessage returns the value of Message.
func (s *ValidationError) GetMessage() OptString {
        return s.Message
}

// GetErrors returns the value of Errors.
func (s *ValidationError) GetErrors() OptValidationErrorErrors {
        return s.Errors
}

// SetMessage sets the value of Message.
func (s *ValidationError) SetMessage(val OptString) {
        s.Message = val
}

// SetErrors sets the value of Errors.
func (s *ValidationError) SetErrors(val OptValidationErrorErrors) {
        s.Errors = val
}

func (*ValidationError) setConfigurationRes()      {}
func (*ValidationError) storeAccountRes()          {}
func (*ValidationError) storeAttachmentRes()       {}
func (*ValidationError) storeBillRes()             {}
func (*ValidationError) storeBudgetLimitRes()      {}
func (*ValidationError) storeBudgetRes()           {}
func (*ValidationError) storeCategoryRes()         {}
func (*ValidationError) storeCurrencyRes()         {}
func (*ValidationError) storeLinkTypeRes()         {}
func (*ValidationError) storePiggyBankRes()        {}
func (*ValidationError) storePreferenceRes()       {}
func (*ValidationError) storeRecurrenceRes()       {}
func (*ValidationError) storeRuleGroupRes()        {}
func (*ValidationError) storeRuleRes()             {}
func (*ValidationError) storeTagRes()              {}
func (*ValidationError) storeTransactionLinkRes()  {}
func (*ValidationError) storeTransactionRes()      {}
func (*ValidationError) storeUserRes()             {}
func (*ValidationError) storeWebhookRes()          {}
func (*ValidationError) updateAccountRes()         {}
func (*ValidationError) updateAttachmentRes()      {}
func (*ValidationError) updateBillRes()            {}
func (*ValidationError) updateBudgetLimitRes()     {}
func (*ValidationError) updateBudgetRes()          {}
func (*ValidationError) updateCategoryRes()        {}
func (*ValidationError) updateCurrencyRes()        {}
func (*ValidationError) updateLinkTypeRes()        {}
func (*ValidationError) updateObjectGroupRes()     {}
func (*ValidationError) updatePiggyBankRes()       {}
func (*ValidationError) updatePreferenceRes()      {}
func (*ValidationError) updateRecurrenceRes()      {}
func (*ValidationError) updateRuleGroupRes()       {}
func (*ValidationError) updateRuleRes()            {}
func (*ValidationError) updateTagRes()             {}
func (*ValidationError) updateTransactionLinkRes() {}
func (*ValidationError) updateTransactionRes()     {}
func (*ValidationError) updateUserRes()            {}
func (*ValidationError) updateWebhookRes()         {}
func (*ValidationError) uploadAttachmentRes()      {}

type ValidationErrorErrors struct {
        Email       []string `json:"email"`
        Blocked     []string `json:"blocked"`
        Role        []string `json:"role"`
        BlockedCode []string `json:"blocked_code"`
        Name        []string `json:"name"`
        Type        []string `json:"type"`
        Iban        []string `json:"iban"`
        Start       []string `json:"start"`
        End         []string `json:"end"`
        Date        []string `json:"date"`
}

// GetEmail returns the value of Email.
func (s *ValidationErrorErrors) GetEmail() []string {
        return s.Email
}

// GetBlocked returns the value of Blocked.
func (s *ValidationErrorErrors) GetBlocked() []string {
        return s.Blocked
}

// GetRole returns the value of Role.
func (s *ValidationErrorErrors) GetRole() []string {
        return s.Role
}

// GetBlockedCode returns the value of BlockedCode.
func (s *ValidationErrorErrors) GetBlockedCode() []string {
        return s.BlockedCode
}

// GetName returns the value of Name.
func (s *ValidationErrorErrors) GetName() []string {
        return s.Name
}

// GetType returns the value of Type.
func (s *ValidationErrorErrors) GetType() []string {
        return s.Type
}

// GetIban returns the value of Iban.
func (s *ValidationErrorErrors) GetIban() []string {
        return s.Iban
}

// GetStart returns the value of Start.
func (s *ValidationErrorErrors) GetStart() []string {
        return s.Start
}

// GetEnd returns the value of End.
func (s *ValidationErrorErrors) GetEnd() []string {
        return s.End
}

// GetDate returns the value of Date.
func (s *ValidationErrorErrors) GetDate() []string {
        return s.Date
}

// SetEmail sets the value of Email.
func (s *ValidationErrorErrors) SetEmail(val []string) {
        s.Email = val
}

// SetBlocked sets the value of Blocked.
func (s *ValidationErrorErrors) SetBlocked(val []string) {
        s.Blocked = val
}

// SetRole sets the value of Role.
func (s *ValidationErrorErrors) SetRole(val []string) {
        s.Role = val
}

// SetBlockedCode sets the value of BlockedCode.
func (s *ValidationErrorErrors) SetBlockedCode(val []string) {
        s.BlockedCode = val
}

// SetName sets the value of Name.
func (s *ValidationErrorErrors) SetName(val []string) {
        s.Name = val
}

// SetType sets the value of Type.
func (s *ValidationErrorErrors) SetType(val []string) {
        s.Type = val
}

// SetIban sets the value of Iban.
func (s *ValidationErrorErrors) SetIban(val []string) {
        s.Iban = val
}

// SetStart sets the value of Start.
func (s *ValidationErrorErrors) SetStart(val []string) {
        s.Start = val
}

// SetEnd sets the value of End.
func (s *ValidationErrorErrors) SetEnd(val []string) {
        s.End = val
}

// SetDate sets the value of Date.
func (s *ValidationErrorErrors) SetDate(val []string) {
        s.Date = val
}

// Ref: #/components/schemas/Webhook
type Webhook struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // Boolean to indicate if the webhook is active.
        Active OptBool `json:"active"`
        // A title for the webhook for easy recognition.
        Title string `json:"title"`
        // A 24-character secret for the webhook. It's generated by Firefly III when saving a new webhook. If
        // you submit a new secret through the PUT endpoint it will generate a new secret for the selected
        // webhook, a new secret bearing no relation to whatever you just submitted.
        Secret   OptString       `json:"secret"`
        Trigger  WebhookTrigger  `json:"trigger"`
        Response WebhookResponse `json:"response"`
        Delivery WebhookDelivery `json:"delivery"`
        // The URL of the webhook. Has to start with `https`.
        URL string `json:"url"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *Webhook) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *Webhook) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetActive returns the value of Active.
func (s *Webhook) GetActive() OptBool {
        return s.Active
}

// GetTitle returns the value of Title.
func (s *Webhook) GetTitle() string {
        return s.Title
}

// GetSecret returns the value of Secret.
func (s *Webhook) GetSecret() OptString {
        return s.Secret
}

// GetTrigger returns the value of Trigger.
func (s *Webhook) GetTrigger() WebhookTrigger {
        return s.Trigger
}

// GetResponse returns the value of Response.
func (s *Webhook) GetResponse() WebhookResponse {
        return s.Response
}

// GetDelivery returns the value of Delivery.
func (s *Webhook) GetDelivery() WebhookDelivery {
        return s.Delivery
}

// GetURL returns the value of URL.
func (s *Webhook) GetURL() string {
        return s.URL
}

// SetCreatedAt sets the value of CreatedAt.
func (s *Webhook) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *Webhook) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetActive sets the value of Active.
func (s *Webhook) SetActive(val OptBool) {
        s.Active = val
}

// SetTitle sets the value of Title.
func (s *Webhook) SetTitle(val string) {
        s.Title = val
}

// SetSecret sets the value of Secret.
func (s *Webhook) SetSecret(val OptString) {
        s.Secret = val
}

// SetTrigger sets the value of Trigger.
func (s *Webhook) SetTrigger(val WebhookTrigger) {
        s.Trigger = val
}

// SetResponse sets the value of Response.
func (s *Webhook) SetResponse(val WebhookResponse) {
        s.Response = val
}

// SetDelivery sets the value of Delivery.
func (s *Webhook) SetDelivery(val WebhookDelivery) {
        s.Delivery = val
}

// SetURL sets the value of URL.
func (s *Webhook) SetURL(val string) {
        s.URL = val
}

// Ref: #/components/schemas/WebhookArray
type WebhookArray struct {
        Data  []WebhookRead `json:"data"`
        Meta  Meta          `json:"meta"`
        Links PageLink      `json:"links"`
}

// GetData returns the value of Data.
func (s *WebhookArray) GetData() []WebhookRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *WebhookArray) GetMeta() Meta {
        return s.Meta
}

// GetLinks returns the value of Links.
func (s *WebhookArray) GetLinks() PageLink {
        return s.Links
}

// SetData sets the value of Data.
func (s *WebhookArray) SetData(val []WebhookRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *WebhookArray) SetMeta(val Meta) {
        s.Meta = val
}

// SetLinks sets the value of Links.
func (s *WebhookArray) SetLinks(val PageLink) {
        s.Links = val
}

func (*WebhookArray) listWebhookRes() {}

// Ref: #/components/schemas/WebhookAttempt
type WebhookAttempt struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // The ID of the webhook message this attempt belongs to.
        WebhookMessageID OptString `json:"webhook_message_id"`
        // The HTTP status code of the error, if any.
        StatusCode OptNilInt32 `json:"status_code"`
        // Internal log for this attempt. May contain sensitive user data.
        Logs OptNilString `json:"logs"`
        // Webhook receiver response for this attempt, if any. May contain sensitive user data.
        Response OptNilString `json:"response"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *WebhookAttempt) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *WebhookAttempt) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetWebhookMessageID returns the value of WebhookMessageID.
func (s *WebhookAttempt) GetWebhookMessageID() OptString {
        return s.WebhookMessageID
}

// GetStatusCode returns the value of StatusCode.
func (s *WebhookAttempt) GetStatusCode() OptNilInt32 {
        return s.StatusCode
}

// GetLogs returns the value of Logs.
func (s *WebhookAttempt) GetLogs() OptNilString {
        return s.Logs
}

// GetResponse returns the value of Response.
func (s *WebhookAttempt) GetResponse() OptNilString {
        return s.Response
}

// SetCreatedAt sets the value of CreatedAt.
func (s *WebhookAttempt) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *WebhookAttempt) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetWebhookMessageID sets the value of WebhookMessageID.
func (s *WebhookAttempt) SetWebhookMessageID(val OptString) {
        s.WebhookMessageID = val
}

// SetStatusCode sets the value of StatusCode.
func (s *WebhookAttempt) SetStatusCode(val OptNilInt32) {
        s.StatusCode = val
}

// SetLogs sets the value of Logs.
func (s *WebhookAttempt) SetLogs(val OptNilString) {
        s.Logs = val
}

// SetResponse sets the value of Response.
func (s *WebhookAttempt) SetResponse(val OptNilString) {
        s.Response = val
}

// Ref: #/components/schemas/WebhookAttemptArray
type WebhookAttemptArray struct {
        Data []WebhookAttemptRead `json:"data"`
        Meta Meta                 `json:"meta"`
}

// GetData returns the value of Data.
func (s *WebhookAttemptArray) GetData() []WebhookAttemptRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *WebhookAttemptArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *WebhookAttemptArray) SetData(val []WebhookAttemptRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *WebhookAttemptArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*WebhookAttemptArray) getWebhookMessageAttemptsRes() {}

// Ref: #/components/schemas/WebhookAttemptRead
type WebhookAttemptRead struct {
        // Immutable value.
        Type       string         `json:"type"`
        ID         string         `json:"id"`
        Attributes WebhookAttempt `json:"attributes"`
}

// GetType returns the value of Type.
func (s *WebhookAttemptRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *WebhookAttemptRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *WebhookAttemptRead) GetAttributes() WebhookAttempt {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *WebhookAttemptRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *WebhookAttemptRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *WebhookAttemptRead) SetAttributes(val WebhookAttempt) {
        s.Attributes = val
}

// Ref: #/components/schemas/WebhookAttemptSingle
type WebhookAttemptSingle struct {
        Data WebhookAttemptRead `json:"data"`
}

// GetData returns the value of Data.
func (s *WebhookAttemptSingle) GetData() WebhookAttemptRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *WebhookAttemptSingle) SetData(val WebhookAttemptRead) {
        s.Data = val
}

func (*WebhookAttemptSingle) getSingleWebhookMessageAttemptRes() {}

// Format of the delivered response.
// Ref: #/components/schemas/WebhookDelivery
type WebhookDelivery string

const (
        WebhookDeliveryJSON WebhookDelivery = "JSON"
)

// AllValues returns all WebhookDelivery values.
func (WebhookDelivery) AllValues() []WebhookDelivery {
        return []WebhookDelivery{
                WebhookDeliveryJSON,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s WebhookDelivery) MarshalText() ([]byte, error) {
        switch s {
        case WebhookDeliveryJSON:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *WebhookDelivery) UnmarshalText(data []byte) error {
        switch WebhookDelivery(data) {
        case WebhookDeliveryJSON:
                *s = WebhookDeliveryJSON
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/WebhookMessage
type WebhookMessage struct {
        CreatedAt OptDateTime `json:"created_at"`
        UpdatedAt OptDateTime `json:"updated_at"`
        // If this message is sent yet.
        Sent OptBool `json:"sent"`
        // If this message has errored out.
        Errored OptBool `json:"errored"`
        // The ID of the webhook this message belongs to.
        WebhookID OptString `json:"webhook_id"`
        // Long UUID string for identification of this webhook message.
        UUID OptString `json:"uuid"`
        // The actual message that is sent or will be sent as JSON string.
        String OptNilString `json:"string"`
}

// GetCreatedAt returns the value of CreatedAt.
func (s *WebhookMessage) GetCreatedAt() OptDateTime {
        return s.CreatedAt
}

// GetUpdatedAt returns the value of UpdatedAt.
func (s *WebhookMessage) GetUpdatedAt() OptDateTime {
        return s.UpdatedAt
}

// GetSent returns the value of Sent.
func (s *WebhookMessage) GetSent() OptBool {
        return s.Sent
}

// GetErrored returns the value of Errored.
func (s *WebhookMessage) GetErrored() OptBool {
        return s.Errored
}

// GetWebhookID returns the value of WebhookID.
func (s *WebhookMessage) GetWebhookID() OptString {
        return s.WebhookID
}

// GetUUID returns the value of UUID.
func (s *WebhookMessage) GetUUID() OptString {
        return s.UUID
}

// GetString returns the value of String.
func (s *WebhookMessage) GetString() OptNilString {
        return s.String
}

// SetCreatedAt sets the value of CreatedAt.
func (s *WebhookMessage) SetCreatedAt(val OptDateTime) {
        s.CreatedAt = val
}

// SetUpdatedAt sets the value of UpdatedAt.
func (s *WebhookMessage) SetUpdatedAt(val OptDateTime) {
        s.UpdatedAt = val
}

// SetSent sets the value of Sent.
func (s *WebhookMessage) SetSent(val OptBool) {
        s.Sent = val
}

// SetErrored sets the value of Errored.
func (s *WebhookMessage) SetErrored(val OptBool) {
        s.Errored = val
}

// SetWebhookID sets the value of WebhookID.
func (s *WebhookMessage) SetWebhookID(val OptString) {
        s.WebhookID = val
}

// SetUUID sets the value of UUID.
func (s *WebhookMessage) SetUUID(val OptString) {
        s.UUID = val
}

// SetString sets the value of String.
func (s *WebhookMessage) SetString(val OptNilString) {
        s.String = val
}

// Ref: #/components/schemas/WebhookMessageArray
type WebhookMessageArray struct {
        Data []WebhookMessageRead `json:"data"`
        Meta Meta                 `json:"meta"`
}

// GetData returns the value of Data.
func (s *WebhookMessageArray) GetData() []WebhookMessageRead {
        return s.Data
}

// GetMeta returns the value of Meta.
func (s *WebhookMessageArray) GetMeta() Meta {
        return s.Meta
}

// SetData sets the value of Data.
func (s *WebhookMessageArray) SetData(val []WebhookMessageRead) {
        s.Data = val
}

// SetMeta sets the value of Meta.
func (s *WebhookMessageArray) SetMeta(val Meta) {
        s.Meta = val
}

func (*WebhookMessageArray) getWebhookMessagesRes() {}

// Ref: #/components/schemas/WebhookMessageRead
type WebhookMessageRead struct {
        // Immutable value.
        Type       string         `json:"type"`
        ID         string         `json:"id"`
        Attributes WebhookMessage `json:"attributes"`
}

// GetType returns the value of Type.
func (s *WebhookMessageRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *WebhookMessageRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *WebhookMessageRead) GetAttributes() WebhookMessage {
        return s.Attributes
}

// SetType sets the value of Type.
func (s *WebhookMessageRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *WebhookMessageRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *WebhookMessageRead) SetAttributes(val WebhookMessage) {
        s.Attributes = val
}

// Ref: #/components/schemas/WebhookMessageSingle
type WebhookMessageSingle struct {
        Data WebhookMessageRead `json:"data"`
}

// GetData returns the value of Data.
func (s *WebhookMessageSingle) GetData() WebhookMessageRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *WebhookMessageSingle) SetData(val WebhookMessageRead) {
        s.Data = val
}

func (*WebhookMessageSingle) getSingleWebhookMessageRes() {}

// Ref: #/components/schemas/WebhookRead
type WebhookRead struct {
        // Immutable value.
        Type       string     `json:"type"`
        ID         string     `json:"id"`
        Attributes Webhook    `json:"attributes"`
        Links      ObjectLink `json:"links"`
}

// GetType returns the value of Type.
func (s *WebhookRead) GetType() string {
        return s.Type
}

// GetID returns the value of ID.
func (s *WebhookRead) GetID() string {
        return s.ID
}

// GetAttributes returns the value of Attributes.
func (s *WebhookRead) GetAttributes() Webhook {
        return s.Attributes
}

// GetLinks returns the value of Links.
func (s *WebhookRead) GetLinks() ObjectLink {
        return s.Links
}

// SetType sets the value of Type.
func (s *WebhookRead) SetType(val string) {
        s.Type = val
}

// SetID sets the value of ID.
func (s *WebhookRead) SetID(val string) {
        s.ID = val
}

// SetAttributes sets the value of Attributes.
func (s *WebhookRead) SetAttributes(val Webhook) {
        s.Attributes = val
}

// SetLinks sets the value of Links.
func (s *WebhookRead) SetLinks(val ObjectLink) {
        s.Links = val
}

// Indicator for what Firefly III will deliver to the webhook URL.
// Ref: #/components/schemas/WebhookResponse
type WebhookResponse string

const (
        WebhookResponseTRANSACTIONS WebhookResponse = "TRANSACTIONS"
        WebhookResponseACCOUNTS     WebhookResponse = "ACCOUNTS"
        WebhookResponseNONE         WebhookResponse = "NONE"
)

// AllValues returns all WebhookResponse values.
func (WebhookResponse) AllValues() []WebhookResponse {
        return []WebhookResponse{
                WebhookResponseTRANSACTIONS,
                WebhookResponseACCOUNTS,
                WebhookResponseNONE,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s WebhookResponse) MarshalText() ([]byte, error) {
        switch s {
        case WebhookResponseTRANSACTIONS:
                return []byte(s), nil
        case WebhookResponseACCOUNTS:
                return []byte(s), nil
        case WebhookResponseNONE:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *WebhookResponse) UnmarshalText(data []byte) error {
        switch WebhookResponse(data) {
        case WebhookResponseTRANSACTIONS:
                *s = WebhookResponseTRANSACTIONS
                return nil
        case WebhookResponseACCOUNTS:
                *s = WebhookResponseACCOUNTS
                return nil
        case WebhookResponseNONE:
                *s = WebhookResponseNONE
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/WebhookSingle
type WebhookSingle struct {
        Data WebhookRead `json:"data"`
}

// GetData returns the value of Data.
func (s *WebhookSingle) GetData() WebhookRead {
        return s.Data
}

// SetData sets the value of Data.
func (s *WebhookSingle) SetData(val WebhookRead) {
        s.Data = val
}

func (*WebhookSingle) getWebhookRes()    {}
func (*WebhookSingle) storeWebhookRes()  {}
func (*WebhookSingle) updateWebhookRes() {}

// Ref: #/components/schemas/WebhookStore
type WebhookStore struct {
        // Boolean to indicate if the webhook is active.
        Active OptBool `json:"active"`
        // A title for the webhook for easy recognition.
        Title    string          `json:"title"`
        Trigger  WebhookTrigger  `json:"trigger"`
        Response WebhookResponse `json:"response"`
        Delivery WebhookDelivery `json:"delivery"`
        // The URL of the webhook. Has to start with `https`.
        URL string `json:"url"`
}

// GetActive returns the value of Active.
func (s *WebhookStore) GetActive() OptBool {
        return s.Active
}

// GetTitle returns the value of Title.
func (s *WebhookStore) GetTitle() string {
        return s.Title
}

// GetTrigger returns the value of Trigger.
func (s *WebhookStore) GetTrigger() WebhookTrigger {
        return s.Trigger
}

// GetResponse returns the value of Response.
func (s *WebhookStore) GetResponse() WebhookResponse {
        return s.Response
}

// GetDelivery returns the value of Delivery.
func (s *WebhookStore) GetDelivery() WebhookDelivery {
        return s.Delivery
}

// GetURL returns the value of URL.
func (s *WebhookStore) GetURL() string {
        return s.URL
}

// SetActive sets the value of Active.
func (s *WebhookStore) SetActive(val OptBool) {
        s.Active = val
}

// SetTitle sets the value of Title.
func (s *WebhookStore) SetTitle(val string) {
        s.Title = val
}

// SetTrigger sets the value of Trigger.
func (s *WebhookStore) SetTrigger(val WebhookTrigger) {
        s.Trigger = val
}

// SetResponse sets the value of Response.
func (s *WebhookStore) SetResponse(val WebhookResponse) {
        s.Response = val
}

// SetDelivery sets the value of Delivery.
func (s *WebhookStore) SetDelivery(val WebhookDelivery) {
        s.Delivery = val
}

// SetURL sets the value of URL.
func (s *WebhookStore) SetURL(val string) {
        s.URL = val
}

// The triggers for the webhook.
// Ref: #/components/schemas/WebhookTrigger
type WebhookTrigger string

const (
        WebhookTriggerSTORETRANSACTION   WebhookTrigger = "STORE_TRANSACTION"
        WebhookTriggerUPDATETRANSACTION  WebhookTrigger = "UPDATE_TRANSACTION"
        WebhookTriggerDESTROYTRANSACTION WebhookTrigger = "DESTROY_TRANSACTION"
)

// AllValues returns all WebhookTrigger values.
func (WebhookTrigger) AllValues() []WebhookTrigger {
        return []WebhookTrigger{
                WebhookTriggerSTORETRANSACTION,
                WebhookTriggerUPDATETRANSACTION,
                WebhookTriggerDESTROYTRANSACTION,
        }
}

// MarshalText implements encoding.TextMarshaler.
func (s WebhookTrigger) MarshalText() ([]byte, error) {
        switch s {
        case WebhookTriggerSTORETRANSACTION:
                return []byte(s), nil
        case WebhookTriggerUPDATETRANSACTION:
                return []byte(s), nil
        case WebhookTriggerDESTROYTRANSACTION:
                return []byte(s), nil
        default:
                return nil, errors.Errorf("invalid value: %q", s)
        }
}

// UnmarshalText implements encoding.TextUnmarshaler.
func (s *WebhookTrigger) UnmarshalText(data []byte) error {
        switch WebhookTrigger(data) {
        case WebhookTriggerSTORETRANSACTION:
                *s = WebhookTriggerSTORETRANSACTION
                return nil
        case WebhookTriggerUPDATETRANSACTION:
                *s = WebhookTriggerUPDATETRANSACTION
                return nil
        case WebhookTriggerDESTROYTRANSACTION:
                *s = WebhookTriggerDESTROYTRANSACTION
                return nil
        default:
                return errors.Errorf("invalid value: %q", data)
        }
}

// Ref: #/components/schemas/WebhookUpdate
type WebhookUpdate struct {
        // Boolean to indicate if the webhook is active.
        Active OptBool `json:"active"`
        // A title for the webhook for easy recognition.
        Title OptString `json:"title"`
        // A 24-character secret for the webhook. It's generated by Firefly III when saving a new webhook. If
        // you submit a new secret through the PUT endpoint it will generate a new secret for the selected
        // webhook, a new secret bearing no relation to whatever you just submitted.
        Secret   OptString          `json:"secret"`
        Trigger  OptWebhookTrigger  `json:"trigger"`
        Response OptWebhookResponse `json:"response"`
        Delivery OptWebhookDelivery `json:"delivery"`
        // The URL of the webhook. Has to start with `https`.
        URL OptString `json:"url"`
}

// GetActive returns the value of Active.
func (s *WebhookUpdate) GetActive() OptBool {
        return s.Active
}

// GetTitle returns the value of Title.
func (s *WebhookUpdate) GetTitle() OptString {
        return s.Title
}

// GetSecret returns the value of Secret.
func (s *WebhookUpdate) GetSecret() OptString {
        return s.Secret
}

// GetTrigger returns the value of Trigger.
func (s *WebhookUpdate) GetTrigger() OptWebhookTrigger {
        return s.Trigger
}

// GetResponse returns the value of Response.
func (s *WebhookUpdate) GetResponse() OptWebhookResponse {
        return s.Response
}

// GetDelivery returns the value of Delivery.
func (s *WebhookUpdate) GetDelivery() OptWebhookDelivery {
        return s.Delivery
}

// GetURL returns the value of URL.
func (s *WebhookUpdate) GetURL() OptString {
        return s.URL
}

// SetActive sets the value of Active.
func (s *WebhookUpdate) SetActive(val OptBool) {
        s.Active = val
}

// SetTitle sets the value of Title.
func (s *WebhookUpdate) SetTitle(val OptString) {
        s.Title = val
}

// SetSecret sets the value of Secret.
func (s *WebhookUpdate) SetSecret(val OptString) {
        s.Secret = val
}

// SetTrigger sets the value of Trigger.
func (s *WebhookUpdate) SetTrigger(val OptWebhookTrigger) {
        s.Trigger = val
}

// SetResponse sets the value of Response.
func (s *WebhookUpdate) SetResponse(val OptWebhookResponse) {
        s.Response = val
}

// SetDelivery sets the value of Delivery.
func (s *WebhookUpdate) SetDelivery(val OptWebhookDelivery) {
        s.Delivery = val
}

// SetURL sets the value of URL.
func (s *WebhookUpdate) SetURL(val OptString) {
        s.URL = val
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "context"
        "net/http"

        "github.com/go-faster/errors"
)

// SecuritySource is provider of security values (tokens, passwords, etc.).
type SecuritySource interface {
        // FireflyIiiAuth provides firefly_iii_auth security value.
        // Default OAuth2 flow.
        FireflyIiiAuth(ctx context.Context, operationName string) (FireflyIiiAuth, error)
}

func (s *Client) securityFireflyIiiAuth(ctx context.Context, operationName string, req *http.Request) error {
        t, err := s.sec.FireflyIiiAuth(ctx, operationName)
        if err != nil {
                return errors.Wrap(err, "security source \"FireflyIiiAuth\"")
        }
        req.Header.Set("Authorization", "Bearer "+t.Token)
        return nil
}

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
        "fmt"

        "github.com/go-faster/errors"

        "github.com/ogen-go/ogen/validate"
)

func (s *Account) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.AccountRole.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "account_role",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.CreditCardType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "credit_card_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.LiabilityType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "liability_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.LiabilityDirection.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "liability_direction",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.InterestPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "interest_period",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AccountArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AccountRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s AccountRoleProperty) Validate() error {
        switch s {
        case "defaultAsset":
                return nil
        case "sharedAsset":
                return nil
        case "savingAsset":
                return nil
        case "ccAsset":
                return nil
        case "cashWalletAsset":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s AccountSearchFieldFilter) Validate() error {
        switch s {
        case "all":
                return nil
        case "iban":
                return nil
        case "name":
                return nil
        case "number":
                return nil
        case "id":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *AccountSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AccountStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.AccountRole.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "account_role",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.CreditCardType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "credit_card_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.LiabilityType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "liability_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.LiabilityDirection.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "liability_direction",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.InterestPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "interest_period",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s AccountTypeFilter) Validate() error {
        switch s {
        case "all":
                return nil
        case "asset":
                return nil
        case "cash":
                return nil
        case "expense":
                return nil
        case "revenue":
                return nil
        case "special":
                return nil
        case "hidden":
                return nil
        case "liability":
                return nil
        case "liabilities":
                return nil
        case "Default account":
                return nil
        case "Cash account":
                return nil
        case "Asset account":
                return nil
        case "Expense account":
                return nil
        case "Revenue account":
                return nil
        case "Initial balance account":
                return nil
        case "Beneficiary account":
                return nil
        case "Import account":
                return nil
        case "Reconciliation account":
                return nil
        case "Loan":
                return nil
        case "Debt":
                return nil
        case "Mortgage":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s AccountTypeProperty) Validate() error {
        switch s {
        case "Default account":
                return nil
        case "Cash account":
                return nil
        case "Asset account":
                return nil
        case "Expense account":
                return nil
        case "Revenue account":
                return nil
        case "Initial balance account":
                return nil
        case "Beneficiary account":
                return nil
        case "Import account":
                return nil
        case "Reconciliation account":
                return nil
        case "Loan":
                return nil
        case "Debt":
                return nil
        case "Mortgage":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *AccountUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.AccountRole.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "account_role",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.CreditCardType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "credit_card_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.LiabilityType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "liability_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.InterestPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "interest_period",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s AttachableType) Validate() error {
        switch s {
        case "Account":
                return nil
        case "Budget":
                return nil
        case "Bill":
                return nil
        case "TransactionJournal":
                return nil
        case "PiggyBank":
                return nil
        case "Tag":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *Attachment) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.AttachableType.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attachable_type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AttachmentArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AttachmentRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AttachmentSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *AttachmentStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.AttachableType.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attachable_type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s AutoBudgetPeriod) Validate() error {
        switch s {
        case "daily":
                return nil
        case "weekly":
                return nil
        case "monthly":
                return nil
        case "quarterly":
                return nil
        case "half-year":
                return nil
        case "yearly":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s AutoBudgetType) Validate() error {
        switch s {
        case "reset":
                return nil
        case "rollover":
                return nil
        case "none":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s AutocompleteAccountArray) Validate() error {
        alias := ([]AutocompleteAccount)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteBillArray) Validate() error {
        alias := ([]AutocompleteBill)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteBudgetArray) Validate() error {
        alias := ([]AutocompleteBudget)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteCategoryArray) Validate() error {
        alias := ([]AutocompleteCategory)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteCurrencyArray) Validate() error {
        alias := ([]AutocompleteCurrency)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteCurrencyCodeArray) Validate() error {
        alias := ([]AutocompleteCurrencyCode)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteObjectGroupArray) Validate() error {
        alias := ([]AutocompleteObjectGroup)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompletePiggyArray) Validate() error {
        alias := ([]AutocompletePiggy)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompletePiggyBalanceArray) Validate() error {
        alias := ([]AutocompletePiggyBalance)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteRecurrenceArray) Validate() error {
        alias := ([]AutocompleteRecurrence)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteRuleArray) Validate() error {
        alias := ([]AutocompleteRule)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteRuleGroupArray) Validate() error {
        alias := ([]AutocompleteRuleGroup)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteTagArray) Validate() error {
        alias := ([]AutocompleteTag)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteTransactionArray) Validate() error {
        alias := ([]AutocompleteTransaction)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteTransactionIDArray) Validate() error {
        alias := ([]AutocompleteTransactionID)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s AutocompleteTransactionTypeArray) Validate() error {
        alias := ([]AutocompleteTransactionType)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s *AvailableBudgetArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s BasicSummary) Validate() error {
        var failures []validate.FieldError
        for key, elem := range s {
                if err := func() error {
                        if err := elem.Validate(); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        failures = append(failures, validate.FieldError{
                                Name:  key,
                                Error: err,
                        })
                }
        }

        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BasicSummaryEntry) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.MonetaryValue.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "monetary_value",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Bill) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.RepeatFreq.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repeat_freq",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BillArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BillRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s BillRepeatFrequency) Validate() error {
        switch s {
        case "weekly":
                return nil
        case "monthly":
                return nil
        case "quarterly":
                return nil
        case "half-year":
                return nil
        case "yearly":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *BillSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BillStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.RepeatFreq.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repeat_freq",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BillUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.RepeatFreq.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repeat_freq",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Budget) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.AutoBudgetType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.AutoBudgetPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_period",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetLimitArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.AutoBudgetType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.AutoBudgetPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_period",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *BudgetUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.AutoBudgetType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.AutoBudgetPeriod.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "auto_budget_period",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *CategoryArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s ChartLine) Validate() error {
        alias := ([]ChartDataSet)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        return nil
}

func (s ConfigValueFilter) Validate() error {
        switch s {
        case "configuration.is_demo_site":
                return nil
        case "configuration.permission_update_check":
                return nil
        case "configuration.last_update_check":
                return nil
        case "configuration.single_user_mode":
                return nil
        case "firefly.version":
                return nil
        case "firefly.api_version":
                return nil
        case "firefly.default_location":
                return nil
        case "firefly.account_to_transaction":
                return nil
        case "firefly.allowed_opposing_types":
                return nil
        case "firefly.accountRoles":
                return nil
        case "firefly.valid_liabilities":
                return nil
        case "firefly.interest_periods":
                return nil
        case "firefly.enable_external_map":
                return nil
        case "firefly.expected_source_types":
                return nil
        case "app.timezone":
                return nil
        case "firefly.bill_periods":
                return nil
        case "firefly.credit_card_types":
                return nil
        case "firefly.languages":
                return nil
        case "firefly.valid_view_ranges":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s ConfigValueUpdateFilter) Validate() error {
        switch s {
        case "configuration.is_demo_site":
                return nil
        case "configuration.permission_update_check":
                return nil
        case "configuration.last_update_check":
                return nil
        case "configuration.single_user_mode":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *Configuration) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Title.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "title",
                        Error: err,
                })
        }
        if err := func() error {
                if err := s.Value.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "value",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s ConfigurationArray) Validate() error {
        alias := ([]Configuration)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        var failures []validate.FieldError
        for i, elem := range alias {
                if err := func() error {
                        if err := elem.Validate(); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        failures = append(failures, validate.FieldError{
                                Name:  fmt.Sprintf("[%d]", i),
                                Error: err,
                        })
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *ConfigurationSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *ConfigurationUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Value.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "value",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s CreditCardType) Validate() error {
        switch s {
        case "monthlyFull":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *CurrencyArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *CurrencyUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Default.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "default",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s CurrencyUpdateDefault) Validate() error {
        switch s {
        case true:
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s DataDestroyObject) Validate() error {
        switch s {
        case "not_assets_liabilities":
                return nil
        case "budgets":
                return nil
        case "bills":
                return nil
        case "piggy_banks":
                return nil
        case "rules":
                return nil
        case "recurring":
                return nil
        case "categories":
                return nil
        case "tags":
                return nil
        case "object_groups":
                return nil
        case "accounts":
                return nil
        case "asset_accounts":
                return nil
        case "expense_accounts":
                return nil
        case "revenue_accounts":
                return nil
        case "liabilities":
                return nil
        case "transactions":
                return nil
        case "withdrawals":
                return nil
        case "deposits":
                return nil
        case "transfers":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s ExportFileFilter) Validate() error {
        switch s {
        case "csv":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s InsightGroup) Validate() error {
        alias := ([]InsightGroupEntry)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        var failures []validate.FieldError
        for i, elem := range alias {
                if err := func() error {
                        if err := elem.Validate(); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        failures = append(failures, validate.FieldError{
                                Name:  fmt.Sprintf("[%d]", i),
                                Error: err,
                        })
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *InsightGroupEntry) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.DifferenceFloat.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "difference_float",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s InsightTotal) Validate() error {
        alias := ([]InsightTotalEntry)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        var failures []validate.FieldError
        for i, elem := range alias {
                if err := func() error {
                        if err := elem.Validate(); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        failures = append(failures, validate.FieldError{
                                Name:  fmt.Sprintf("[%d]", i),
                                Error: err,
                        })
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *InsightTotalEntry) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.DifferenceFloat.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "difference_float",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s InsightTransfer) Validate() error {
        alias := ([]InsightTransferEntry)(s)
        if alias == nil {
                return errors.New("nil is invalid value")
        }
        var failures []validate.FieldError
        for i, elem := range alias {
                if err := func() error {
                        if err := elem.Validate(); err != nil {
                                return err
                        }
                        return nil
                }(); err != nil {
                        failures = append(failures, validate.FieldError{
                                Name:  fmt.Sprintf("[%d]", i),
                                Error: err,
                        })
                }
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *InsightTransferEntry) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.DifferenceFloat.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "difference_float",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.InFloat.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "in_float",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.OutFloat.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "out_float",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s InterestPeriod) Validate() error {
        switch s {
        case "weekly":
                return nil
        case "monthly":
                return nil
        case "quarterly":
                return nil
        case "half-year":
                return nil
        case "yearly":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s LiabilityDirection) Validate() error {
        switch s {
        case "credit":
                return nil
        case "debit":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s LiabilityType) Validate() error {
        switch s {
        case "loan":
                return nil
        case "debt":
                return nil
        case "mortgage":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *LinkTypeArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *ObjectGroupArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PiggyBank) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Percentage.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "percentage",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PiggyBankArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PiggyBankEventArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PiggyBankRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PiggyBankSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s PolymorphicProperty) Validate() error {
        switch s.Type {
        case BoolPolymorphicProperty:
                return nil // no validation needed
        case StringPolymorphicProperty:
                return nil // no validation needed
        case PolymorphicProperty2PolymorphicProperty:
                return nil // no validation needed
        case StringArrayItemArrayPolymorphicProperty:
                if s.StringArrayItemArray == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        default:
                return errors.Errorf("invalid type %q", s.Type)
        }
}

func (s *Preference) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PreferenceArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PreferenceRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PreferenceSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *PreferenceUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Recurrence) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Type.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Repetitions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repetitions",
                        Error: err,
                })
        }
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceRepetition) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceRepetitionStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s RecurrenceRepetitionType) Validate() error {
        switch s {
        case "daily":
                return nil
        case "weekly":
                return nil
        case "ndom":
                return nil
        case "monthly":
                return nil
        case "yearly":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *RecurrenceRepetitionUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Type.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Repetitions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Repetitions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repetitions",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Transactions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceTransaction) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.SourceType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "source_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.DestinationType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "destination_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceTransactionStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s RecurrenceTransactionType) Validate() error {
        switch s {
        case "withdrawal":
                return nil
        case "transfer":
                return nil
        case "deposit":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *RecurrenceTransactionUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RecurrenceUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Repetitions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "repetitions",
                        Error: err,
                })
        }
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Rule) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Trigger.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Triggers == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Triggers {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "triggers",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Actions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Actions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "actions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleAction) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s RuleActionKeyword) Validate() error {
        switch s {
        case "user_action":
                return nil
        case "set_category":
                return nil
        case "clear_category":
                return nil
        case "set_budget":
                return nil
        case "clear_budget":
                return nil
        case "add_tag":
                return nil
        case "remove_tag":
                return nil
        case "remove_all_tags":
                return nil
        case "set_description":
                return nil
        case "append_description":
                return nil
        case "prepend_description":
                return nil
        case "set_source_account":
                return nil
        case "set_destination_account":
                return nil
        case "set_notes":
                return nil
        case "append_notes":
                return nil
        case "prepend_notes":
                return nil
        case "clear_notes":
                return nil
        case "link_to_bill":
                return nil
        case "convert_withdrawal":
                return nil
        case "convert_deposit":
                return nil
        case "convert_transfer":
                return nil
        case "delete_transaction":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *RuleActionStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleActionUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Type.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleGroupArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Trigger.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Triggers == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Triggers {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "triggers",
                        Error: err,
                })
        }
        if err := func() error {
                if s.Actions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Actions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "actions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleTrigger) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s RuleTriggerKeyword) Validate() error {
        switch s {
        case "from_account_starts":
                return nil
        case "from_account_ends":
                return nil
        case "from_account_is":
                return nil
        case "from_account_contains":
                return nil
        case "to_account_starts":
                return nil
        case "to_account_ends":
                return nil
        case "to_account_is":
                return nil
        case "to_account_contains":
                return nil
        case "amount_less":
                return nil
        case "amount_exactly":
                return nil
        case "amount_more":
                return nil
        case "description_starts":
                return nil
        case "description_ends":
                return nil
        case "description_contains":
                return nil
        case "description_is":
                return nil
        case "transaction_type":
                return nil
        case "category_is":
                return nil
        case "budget_is":
                return nil
        case "tag_is":
                return nil
        case "currency_is":
                return nil
        case "has_attachments":
                return nil
        case "has_no_category":
                return nil
        case "has_any_category":
                return nil
        case "has_no_budget":
                return nil
        case "has_any_budget":
                return nil
        case "has_no_tag":
                return nil
        case "has_any_tag":
                return nil
        case "notes_contains":
                return nil
        case "notes_start":
                return nil
        case "notes_end":
                return nil
        case "notes_are":
                return nil
        case "no_notes":
                return nil
        case "any_notes":
                return nil
        case "source_account_is":
                return nil
        case "destination_account_is":
                return nil
        case "source_account_starts":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *RuleTriggerStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s RuleTriggerType) Validate() error {
        switch s {
        case "store-journal":
                return nil
        case "update-journal":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *RuleTriggerUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Type.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *RuleUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Trigger.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Triggers {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "triggers",
                        Error: err,
                })
        }
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Actions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "actions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s ShortAccountTypeProperty) Validate() error {
        switch s {
        case "asset":
                return nil
        case "expense":
                return nil
        case "import":
                return nil
        case "revenue":
                return nil
        case "cash":
                return nil
        case "liability":
                return nil
        case "liabilities":
                return nil
        case "initial-balance":
                return nil
        case "reconciliation":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *TagArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TagModel) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TagModelStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TagModelUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TagRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TagSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Transaction) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Transactions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionLinkArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionSplit) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.SourceType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "source_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.DestinationType.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "destination_type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Latitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "latitude",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Longitude.Get(); ok {
                        if err := func() error {
                                if err := (validate.Float{}).Validate(float64(value)); err != nil {
                                        return errors.Wrap(err, "float")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "longitude",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionSplitStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Type.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionSplitUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Type.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "type",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Tags.Get(); ok {
                        if err := func() error {
                                if value == nil {
                                        return errors.New("nil is invalid value")
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "tags",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *TransactionStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Transactions == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s TransactionTypeFilter) Validate() error {
        switch s {
        case "all":
                return nil
        case "withdrawal":
                return nil
        case "withdrawals":
                return nil
        case "expense":
                return nil
        case "deposit":
                return nil
        case "deposits":
                return nil
        case "income":
                return nil
        case "transfer":
                return nil
        case "transfers":
                return nil
        case "opening_balance":
                return nil
        case "reconciliation":
                return nil
        case "special":
                return nil
        case "specials":
                return nil
        case "default":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s TransactionTypeProperty) Validate() error {
        switch s {
        case "withdrawal":
                return nil
        case "deposit":
                return nil
        case "transfer":
                return nil
        case "reconciliation":
                return nil
        case "opening balance":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *TransactionUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                var failures []validate.FieldError
                for i, elem := range s.Transactions {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "transactions",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *User) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := (validate.String{
                        MinLength:    0,
                        MinLengthSet: false,
                        MaxLength:    0,
                        MaxLengthSet: false,
                        Email:        true,
                        Hostname:     false,
                        Regex:        nil,
                }).Validate(string(s.Email)); err != nil {
                        return errors.Wrap(err, "string")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "email",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.BlockedCode.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "blocked_code",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Role.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "role",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *UserArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s UserBlockedCodeProperty) Validate() error {
        switch s {
        case "email_changed":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *UserRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s UserRoleProperty) Validate() error {
        switch s {
        case "owner":
                return nil
        case "demo":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *UserSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *Webhook) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Trigger.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                if err := s.Response.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "response",
                        Error: err,
                })
        }
        if err := func() error {
                if err := s.Delivery.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "delivery",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *WebhookArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                var failures []validate.FieldError
                for i, elem := range s.Data {
                        if err := func() error {
                                if err := elem.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                failures = append(failures, validate.FieldError{
                                        Name:  fmt.Sprintf("[%d]", i),
                                        Error: err,
                                })
                        }
                }
                if len(failures) > 0 {
                        return &validate.Error{Fields: failures}
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *WebhookAttemptArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s WebhookDelivery) Validate() error {
        switch s {
        case "JSON":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *WebhookMessageArray) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if s.Data == nil {
                        return errors.New("nil is invalid value")
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *WebhookRead) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Attributes.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "attributes",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s WebhookResponse) Validate() error {
        switch s {
        case "TRANSACTIONS":
                return nil
        case "ACCOUNTS":
                return nil
        case "NONE":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *WebhookSingle) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Data.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "data",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s *WebhookStore) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if err := s.Trigger.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                if err := s.Response.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "response",
                        Error: err,
                })
        }
        if err := func() error {
                if err := s.Delivery.Validate(); err != nil {
                        return err
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "delivery",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

func (s WebhookTrigger) Validate() error {
        switch s {
        case "STORE_TRANSACTION":
                return nil
        case "UPDATE_TRANSACTION":
                return nil
        case "DESTROY_TRANSACTION":
                return nil
        default:
                return errors.Errorf("invalid value: %v", s)
        }
}

func (s *WebhookUpdate) Validate() error {
        var failures []validate.FieldError
        if err := func() error {
                if value, ok := s.Trigger.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "trigger",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Response.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "response",
                        Error: err,
                })
        }
        if err := func() error {
                if value, ok := s.Delivery.Get(); ok {
                        if err := func() error {
                                if err := value.Validate(); err != nil {
                                        return err
                                }
                                return nil
                        }(); err != nil {
                                return err
                        }
                }
                return nil
        }(); err != nil {
                failures = append(failures, validate.FieldError{
                        Name:  "delivery",
                        Error: err,
                })
        }
        if len(failures) > 0 {
                return &validate.Error{Fields: failures}
        }
        return nil
}

package jobs

import (
        "go.uber.org/multierr"
)

type Batch[V any] struct {
        Key   string
        Value V
        Size  int
}

func (b Batch[V]) Run(ctx Context, fn func(ctx Context, value V, limit int) (*V, error)) (errs error) {
        value := b.Value
        for {
                ctx := ctx.With(b.Key, value)
                nextValue, err := fn(ctx, value, b.Size)
                if multierr.AppendInto(&errs, err) || nextValue == nil {
                        return
                }

                value = *nextValue
        }
}

package jobs

import (
        "context"
        "fmt"
        "log/slog"
        "strings"
        "time"

        "github.com/jfk9w/hoarder/internal/logs"

        "github.com/pkg/errors"
        "go.uber.org/multierr"
)

type contextPathElement struct {
        key   string
        value any
}

type contextPath []contextPathElement

func (p contextPath) String() string {
        var b strings.Builder
        for _, el := range p {
                b.WriteString(fmt.Sprintf("%v: ", el.value))
        }

        return b.String()
}

type AskFunc func(ctx context.Context, text string) (string, error)

type Context struct {
        std   context.Context
        log   *slog.Logger
        path  contextPath
        askFn AskFunc
}

func NewContext(ctx context.Context, log *slog.Logger) Context {
        return Context{
                std: ctx,
                log: log,
        }
}

func (ctx Context) Deadline() (time.Time, bool) { return ctx.std.Deadline() }
func (ctx Context) Done() <-chan struct{}       { return ctx.std.Done() }
func (ctx Context) Err() error                  { return ctx.std.Err() }
func (ctx Context) Value(key any) any           { return ctx.std.Value(key) }

func (ctx Context) Debug(msg string, args ...any) { ctx.log.Debug(msg, args...) }
func (ctx Context) Info(msg string, args ...any)  { ctx.log.Info(msg, args...) }
func (ctx Context) Warn(msg string, args ...any)  { ctx.log.Warn(msg, args...) }

func (ctx Context) With(key string, value any) Context {
        ctx.log = ctx.log.With(slog.Any(key, value))
        ctx.path = append(ctx.path, contextPathElement{key, value})
        return ctx
}

func (ctx Context) withLog(key string, value any) Context {
        ctx.log = ctx.log.With(slog.Any(key, value))
        return ctx
}

func (ctx Context) WithAskFn(askFn AskFunc) Context {
        ctx.askFn = askFn
        return ctx
}

func (ctx Context) ApplyAskFn(fn func(ctx context.Context, askFn AskFunc) context.Context) Context {
        if ctx.askFn != nil {
                ctx.std = fn(ctx.std, ctx.askFn)
        }

        return ctx
}

func (ctx Context) Error(errs *error, err error, msg string) bool {
        if err == nil {
                return false
        }

        _ = multierr.AppendInto(errs, errors.Errorf("%s%s", ctx.path.String(), msg))
        ctx.log.Error(msg, logs.Error(err))

        return true
}

package jobs

import (
        "errors"
        "sync"
        "time"

        "github.com/jfk9w/hoarder/internal/common"
)

const All = "all"

var ErrJobUnconfigured = errors.New("job not configured")

type Interface interface {
        Info() Info
        Run(ctx Context, now time.Time, userID string) error
}

type Info struct {
        ID          string
        Description string
}

type Result struct {
        JobID string
        Error error
}

type exclusiveJob struct {
        job   Interface
        users common.MultiMutex[string]
}

func (j *exclusiveJob) Info() Info {
        return j.job.Info()
}

func (j *exclusiveJob) Run(ctx Context, now time.Time, userID string) (errs error) {
        cancel, err := j.users.TryLock(userID)
        if ctx.Error(&errs, err, "already running") {
                return
        }

        defer cancel()
        return j.job.Run(ctx, now, userID)
}

type Registry struct {
        jobs []exclusiveJob
}

func (r *Registry) Register(job Interface) {
        r.jobs = append(r.jobs, exclusiveJob{job: job})
}

func (r *Registry) Info() []Info {
        infos := make([]Info, len(r.jobs)+1)
        for i := range r.jobs {
                infos[i] = r.jobs[i].Info()
        }

        infos[len(r.jobs)] = Info{
                ID:          All,
                Description: "Запуск всех джобов",
        }

        return infos
}

func (r *Registry) Run(ctx Context, now time.Time, userID string, jobIDs []string) []Result {
        var filter func(id string) bool
        if len(jobIDs) == 0 || jobIDs[0] == All {
                filter = func(_ string) bool { return true }
        } else {
                uniqueJobIDs := make(map[string]bool)
                for _, jobID := range jobIDs {
                        uniqueJobIDs[jobID] = true
                }

                filter = func(id string) bool { return uniqueJobIDs[id] }
        }

        var (
                results    []Result
                configured = false
                wg         sync.WaitGroup
                mu         sync.Mutex
        )

        for i := range r.jobs {
                job := &r.jobs[i]
                jobID := job.Info().ID
                if !filter(jobID) {
                        continue
                }

                wg.Add(1)
                go func() {
                        defer wg.Done()
                        err := job.Run(ctx.withLog("job", jobID), now, userID)
                        jobConfigured := !errors.Is(err, ErrJobUnconfigured)

                        mu.Lock()
                        defer mu.Unlock()
                        if !configured && jobConfigured {
                                results = nil
                                configured = true
                        }

                        if jobConfigured == configured {
                                results = append(results, Result{JobID: jobID, Error: err})
                        }
                }()
        }

        wg.Wait()
        return results
}

package lkdr

import (
        "context"
        "fmt"

        "github.com/jfk9w-go/lkdr-api"

        "github.com/jfk9w/hoarder/internal/captcha"
        "github.com/jfk9w/hoarder/internal/jobs"
)

type authorizer struct {
        captcha.TokenProvider
        askFn jobs.AskFunc
}

func (a authorizer) GetConfirmationCode(ctx context.Context, phone string) (string, error) {
        return a.askFn(ctx, fmt.Sprintf(`Код подтверждения для сервиса "Мои чеки онлайн" • %s:`, phone))
}

func withAuthorizer(captchaSolver captcha.TokenProvider) func(ctx context.Context, askFn jobs.AskFunc) context.Context {
        return func(ctx context.Context, askFn jobs.AskFunc) context.Context {
                if captchaSolver == nil {
                        return ctx
                }

                return lkdr.WithAuthorizer(ctx, authorizer{
                        TokenProvider: captchaSolver,
                        askFn:         askFn,
                })
        }
}

package lkdr

import (
        "context"
        "time"

        "github.com/jfk9w-go/lkdr-api"
)

type boundClient struct {
        client  Client
        timeout time.Duration
}

func (c *boundClient) Receipt(ctx context.Context, in *lkdr.ReceiptIn) (*lkdr.ReceiptOut, error) {
        ctx, cancel := context.WithTimeout(ctx, c.timeout)
        defer cancel()
        return c.client.Receipt(ctx, in)
}

func (c *boundClient) FiscalData(ctx context.Context, in *lkdr.FiscalDataIn) (*lkdr.FiscalDataOut, error) {
        ctx, cancel := context.WithTimeout(ctx, c.timeout)
        defer cancel()
        return c.client.FiscalData(ctx, in)
}

package entities

import (
        "database/sql/driver"
        "time"

        "github.com/jfk9w-go/lkdr-api"
        "github.com/pkg/errors"
)

type DateTime struct {
        lkdr.DateTime
}

func (dt DateTime) GormDataType() string {
        return "time"
}

func (dt DateTime) Value() (driver.Value, error) {
        return dt.Time(), nil
}

func (dt *DateTime) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                dt.DateTime = lkdr.DateTime(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type DateTimeTZ struct {
        lkdr.DateTimeTZ
}

func (dt DateTimeTZ) GormDataType() string {
        return "time"
}

func (dt DateTimeTZ) Value() (driver.Value, error) {
        return dt.Time(), nil
}

func (dt *DateTimeTZ) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                dt.DateTimeTZ = lkdr.DateTimeTZ(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

package entities

type FiscalDataItem struct {
        ReceiptKey string `json:"-" gorm:"primaryKey"`
        DbIdx      int    `json:"dbIdx" gorm:"primaryKey"`

        Name        string  `json:"name"`
        Nds         int     `json:"nds"`
        PaymentType int     `json:"paymentType"`
        Price       float64 `json:"price"`
        ProductType int     `json:"productType"`
        ProviderInn *string `json:"providerInn"`
        Quantity    float64 `json:"quantity"`
        Sum         float64 `json:"sum"`
}

type FiscalData struct {
        ReceiptKey string  `json:"-" gorm:"primaryKey"`
        Receipt    Receipt `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        BuyerAddress            string           `json:"buyerAddress"`
        CashTotalSum            float64          `json:"cashTotalSum"`
        CreditSum               float64          `json:"creditSum"`
        DateTime                DateTime         `json:"dateTime"`
        EcashTotalSum           float64          `json:"ecashTotalSum"`
        FiscalDocumentFormatVer string           `json:"fiscalDocumentFormatVer"`
        FiscalDocumentNumber    int64            `json:"fiscalDocumentNumber"`
        FiscalDriveNumber       string           `json:"fiscalDriveNumber"`
        FiscalSign              string           `json:"fiscalSign"`
        InternetSign            *int             `json:"internetSign"`
        Items                   []FiscalDataItem `json:"items" gorm:"constraint:OnDelete:CASCADE;foreignKey:ReceiptKey"`
        KktRegId                string           `json:"kktRegId"`
        MachineNumber           *string          `json:"machineNumber"`
        Nds10                   *float64         `json:"nds10"`
        Nds18                   *float64         `json:"nds18"`
        OperationType           int              `json:"operationType"`
        Operator                *string          `json:"operator"`
        PrepaidSum              float64          `json:"prepaidSum"`
        ProvisionSum            float64          `json:"provisionSum"`
        RequestNumber           int64            `json:"requestNumber"`
        RetailPlace             string           `json:"retailPlace"`
        RetailPlaceAddress      *string          `json:"retailPlaceAddress"`
        ShiftNumber             int64            `json:"shiftNumber"`
        TaxationType            int              `json:"taxationType"`
        TotalSum                float64          `json:"totalSum"`
        User                    *string          `json:"user"`
        UserInn                 string           `json:"userInn"`
}

func (fd FiscalData) TableName() string {
        return "fiscal_data"
}

package entities

type Brand struct {
        Description string  `json:"description"`
        Id          int64   `json:"id" gorm:"primaryKey;autoIncrement:false"`
        Image       *string `json:"image"`
        Name        string  `json:"name"`
}

type Receipt struct {
        UserPhone string `json:"-" gorm:"index"`
        User      User   `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        BrandId *int64 `json:"brandId" gorm:"index"`
        Brand   *Brand `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        Buyer                string   `json:"buyer"`
        BuyerType            string   `json:"buyerType"`
        CreatedDate          DateTime `json:"createdDate" gorm:"index"`
        FiscalDocumentNumber string   `json:"fiscalDocumentNumber"`
        FiscalDriveNumber    string   `json:"fiscalDriveNumber"`
        Key                  string   `json:"key" gorm:"primaryKey"`
        KktOwner             string   `json:"kktOwner"`
        KktOwnerInn          string   `json:"kktOwnerInn"`
        ReceiveDate          DateTime `json:"receiveDate" gorm:"index"`
        TotalSum             string   `json:"totalSum"`
}

func (r Receipt) TableName() string {
        return "receipts"
}

package loaders

import (
        "strings"

        "github.com/AlekSi/pointer"
        "github.com/jfk9w-go/lkdr-api"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        "github.com/jfk9w/hoarder/internal/jobs/lkdr/internal/entities"
        "github.com/jfk9w/hoarder/internal/logs"
)

type FiscalData struct {
        Phone     string
        BatchSize int
}

func (l FiscalData) TableName() string {
        return new(entities.FiscalData).TableName()
}

func (l FiscalData) Load(ctx jobs.Context, client Client, db database.DB) (_ []Interface, errs error) {
        return nil, jobs.Batch[int]{
                Key:  "offset",
                Size: l.BatchSize,
        }.Run(ctx, fiscalDataBatch{
                phone:  l.Phone,
                client: client,
                db:     db,
        }.load)
}

type fiscalDataBatch struct {
        phone  string
        client Client
        db     database.DB
}

func (l fiscalDataBatch) load(ctx jobs.Context, offset, limit int) (nextOffset *int, errs error) {
        var pendingReceipts []struct {
                Key           string
                HasFiscalData bool
        }

        if err := l.db.WithContext(ctx).
                Model(new(entities.Receipt)).
                Select("receipts.key, fiscal_data.receipt_key is not null as has_fiscal_data").
                Joins("left join fiscal_data on receipts.key = fiscal_data.receipt_key").
                Where("receipts.user_phone = ?", l.phone).
                Order("receive_date asc").
                Offset(offset).
                Limit(limit).
                Scan(&pendingReceipts).
                Error; ctx.Error(&errs, err, "failed to select pending receipts") {
                return
        }

        for _, pendingReceipt := range pendingReceipts {
                if pendingReceipt.HasFiscalData {
                        continue
                }

                key := pendingReceipt.Key
                ctx := ctx.With("key", key)

                out, err := l.client.FiscalData(ctx, &lkdr.FiscalDataIn{Key: key})
                if err != nil {
                        if lkdr.IsDataNotFound(err) {
                                ctx.Warn("fiscal data not found", logs.Error(err))
                                continue
                        }

                        msg := "failed to get data from api"
                        if strings.Contains(err.Error(), "Внутреняя ошибка. Попробуйте еще раз") {
                                ctx.Warn(msg, logs.Error(err))
                                continue
                        }

                        _ = ctx.Error(&errs, err, msg)
                        return
                }

                entity, err := database.ToViaJSON[entities.FiscalData](out)
                if ctx.Error(&errs, err, "entity conversion failed") {
                        return
                }

                entity.ReceiptKey = key

                if err := l.db.WithContext(ctx).
                        Upsert(&entity).
                        Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                ctx.Debug("updated entity in db")
        }

        if len(pendingReceipts) == limit {
                nextOffset = pointer.To(offset + limit)
        }

        return
}

package loaders

import (
        "database/sql"
        "strings"

        "github.com/AlekSi/pointer"
        "github.com/jfk9w-go/lkdr-api"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        "github.com/jfk9w/hoarder/internal/jobs/lkdr/internal/entities"
        "github.com/jfk9w/hoarder/internal/logs"
)

type Receipts struct {
        Phone     string
        BatchSize int
}

func (l Receipts) TableName() string {
        return new(entities.Receipt).TableName()
}

func (l Receipts) Load(ctx jobs.Context, client Client, db database.DB) (_ []Interface, errs error) {
        var from sql.NullTime
        if err := db.WithContext(ctx).
                Model(new(entities.Receipt)).
                Select("receive_date").
                Where("user_phone = ?", l.Phone).
                Order("receive_date desc").
                Limit(1).
                Scan(&from).
                Error; ctx.Error(&errs, err, "failed to select latest date") {
                return
        }

        var dateFrom *lkdr.Date
        if from.Valid {
                dateFrom = pointer.To(lkdr.Date(from.Time))
        }

        return nil, jobs.Batch[int]{
                Key:  "offset",
                Size: l.BatchSize,
        }.Run(ctx, receiptsBatch{
                phone:    l.Phone,
                client:   client,
                db:       db,
                dateFrom: dateFrom,
        }.load)
}

type receiptsBatch struct {
        phone    string
        client   Client
        db       database.DB
        dateFrom *lkdr.Date
}

func (l receiptsBatch) load(ctx jobs.Context, offset int, limit int) (nextOffset *int, errs error) {
        in := &lkdr.ReceiptIn{
                DateFrom: l.dateFrom,
                OrderBy:  "RECEIVE_DATE:ASC",
                Offset:   offset,
                Limit:    limit,
        }

        out, err := l.client.Receipt(ctx, in)
        if err != nil {
                msg := "failed to get data from api"
                if strings.Contains(err.Error(), "Внутреняя ошибка. Попробуйте еще раз") {
                        ctx.Warn(msg, logs.Error(err))
                        return
                }

                _ = ctx.Error(&errs, err, msg)
                return
        }

        type Entities struct {
                Brands   []entities.Brand   `json:"brands"`
                Receipts []entities.Receipt `json:"receipts"`
        }

        entities, err := database.ToViaJSON[Entities](out)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        if brands := entities.Brands; len(brands) > 0 {
                if err := l.db.WithContext(ctx).
                        Upsert(brands).
                        Error; ctx.Error(&errs, err, "failed to update brands in db") {
                        return
                }

                ctx.Debug("updated brands in db", "count", len(brands))
        }

        if receipts := entities.Receipts; len(receipts) > 0 {
                for i := range receipts {
                        receipts[i].UserPhone = l.phone
                }

                if err := l.db.WithContext(ctx).
                        Upsert(receipts).
                        Error; ctx.Error(&errs, err, "failed to update receipts in db") {
                        return
                }

                ctx.Debug("updated receipts in db", "count", len(receipts))
        }

        if out.HasMore {
                nextOffset = pointer.To(offset + limit)
        }

        return
}

package lkdr

import (
        "context"
        "hash/fnv"
        "log/slog"
        "math/rand"
        "time"

        "github.com/jfk9w-go/based"
        "github.com/jfk9w-go/lkdr-api"
        "github.com/pkg/errors"
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/captcha"
        "github.com/jfk9w/hoarder/internal/common"
        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/lkdr/internal/entities"
        "github.com/jfk9w/hoarder/internal/jobs/lkdr/internal/loaders"
        "github.com/jfk9w/hoarder/internal/logs"
)

const JobID = "lkdr"

type JobParams struct {
        Config        Config       `validate:"required"`
        Clock         based.Clock  `validate:"required"`
        Logger        *slog.Logger `validate:"required"`
        ClientFactory ClientFactory
        CaptchaSolver captcha.TokenProvider
}

type Job struct {
        users         map[string]map[string]Client
        batchSize     int
        captchaSolver captcha.TokenProvider
        db            database.DB
}

func NewJob(ctx context.Context, params JobParams) (*Job, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        if params.ClientFactory == nil {
                params.ClientFactory = defaultClientFactory
        }

        db, err := database.Open(ctx, database.Params{
                Clock:    params.Clock,
                Logger:   params.Logger.With(logs.Database(JobID)),
                Config:   params.Config.Database,
                Entities: entities,
        })

        if err != nil {
                return nil, err
        }

        storage := &storage{db: db}
        users := make(map[string]map[string]Client)
        for user, credentials := range params.Config.Users {
                phones := make(map[string]Client)
                users[user] = phones
                for _, credential := range credentials {
                        deviceID := credential.DeviceID
                        if deviceID == "" {
                                var err error
                                deviceID, err = generateDeviceID(credential.UserAgent, credential.Phone)
                                if err != nil {
                                        return nil, errors.Wrap(err, "generate device ID")
                                }
                        }

                        client, err := lkdr.NewClient(lkdr.ClientParams{
                                Phone:        credential.Phone,
                                Clock:        params.Clock,
                                DeviceID:     deviceID,
                                UserAgent:    credential.UserAgent,
                                TokenStorage: storage,
                        })

                        if err != nil {
                                return nil, errors.Wrapf(err, "create client for %s/%s", user, credential.Phone)
                        }

                        phones[credential.Phone] = &boundClient{
                                client:  client,
                                timeout: params.Config.Timeout,
                        }
                }
        }

        return &Job{
                users:         users,
                batchSize:     params.Config.BatchSize,
                captchaSolver: params.CaptchaSolver,
                db:            db,
        }, nil
}

func (j *Job) Info() jobs.Info {
        return jobs.Info{
                ID:          JobID,
                Description: `Загрузка данных из сервиса ФНС "Мои чеки онлайн"`,
        }
}

func (j *Job) Run(ctx jobs.Context, _ time.Time, userID string) (errs error) {
        phones := j.users[userID]
        if phones == nil {
                return jobs.ErrJobUnconfigured
        }

        ctx = ctx.ApplyAskFn(withAuthorizer(j.captchaSolver))
        for phone, client := range phones {
                ctx := ctx.With("phone", phone)
                err := j.executeLoaders(ctx, userID, phone, client)
                _ = multierr.AppendInto(&errs, err)
        }

        return
}

func (j *Job) executeLoaders(ctx jobs.Context, userID, phone string, client Client) (errs error) {
        if err := j.db.WithContext(ctx).
                Upsert(&User{Name: userID, Phone: phone}).
                Error; ctx.Error(&errs, err, "failed to create user in db") {
                return
        }

        var stack common.Stack[loaders.Interface]
        stack.Push(
                loaders.Receipts{Phone: phone, BatchSize: j.batchSize},
                loaders.FiscalData{Phone: phone, BatchSize: j.batchSize},
        )

        for {
                loader, ok := stack.Pop()
                if !ok {
                        break
                }

                ctx := ctx.With("entity", loader.TableName())
                loaders, err := loader.Load(ctx, client, j.db)
                if !multierr.AppendInto(&errs, err) {
                        stack.Push(loaders...)
                }
        }

        return
}

func generateDeviceID(userAgent, phone string) (string, error) {
        hash := fnv.New64()
        if _, err := hash.Write([]byte(userAgent)); err != nil {
                return "", errors.Wrap(err, "hash user agent")
        }

        if _, err := hash.Write([]byte(phone)); err != nil {
                return "", errors.Wrap(err, "hash phone")
        }

        source := rand.NewSource(int64(hash.Sum64()))

        const symbols = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
        var deviceID []byte
        for i := 0; i < 21; i++ {
                deviceID = append(deviceID, symbols[source.Int63()%int64(len(symbols))])
        }

        return string(deviceID), nil
}

package lkdr

import (
        "context"

        "github.com/jfk9w-go/lkdr-api"
)

type Client interface {
        Receipt(ctx context.Context, in *lkdr.ReceiptIn) (*lkdr.ReceiptOut, error)
        FiscalData(ctx context.Context, in *lkdr.FiscalDataIn) (*lkdr.FiscalDataOut, error)
}

type ClientFactory func(params lkdr.ClientParams) (Client, error)

var defaultClientFactory ClientFactory = func(params lkdr.ClientParams) (Client, error) {
        return lkdr.NewClient(params)
}

package lkdr

import (
        "context"

        "github.com/jfk9w-go/lkdr-api"
        "github.com/pkg/errors"
        "gorm.io/gorm"

        "github.com/jfk9w/hoarder/internal/database"
        . "github.com/jfk9w/hoarder/internal/jobs/lkdr/internal/entities"
)

type storage struct {
        db database.DB
}

func (s *storage) LoadTokens(ctx context.Context, phone string) (*lkdr.Tokens, error) {
        var entity Tokens
        if err := s.db.First(&entity, phone).Error; err != nil {
                if errors.Is(err, gorm.ErrRecordNotFound) {
                        return nil, nil
                }

                return nil, errors.Wrap(err, "get tokens from db")
        }

        return database.ToViaJSON[*lkdr.Tokens](entity)
}

func (s *storage) UpdateTokens(ctx context.Context, phone string, tokens *lkdr.Tokens) error {
        if tokens == nil {
                return errors.Wrap(s.db.Delete(new(Tokens), phone).Error, "delete tokens from db")
        }

        entity, err := database.ToViaJSON[*Tokens](tokens)
        if err != nil {
                return err
        }

        entity.UserPhone = phone

        if err := s.db.Upsert(entity).Error; err != nil {
                return errors.Wrap(err, "save tokens in db")
        }

        return nil
}

package tinkoff

import (
        "context"
        "fmt"

        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/jobs"
)

type authorizer struct {
        askFn jobs.AskFunc
}

func (a authorizer) GetConfirmationCode(ctx context.Context, phone string) (string, error) {
        return a.askFn(ctx, fmt.Sprintf(`Код подтверждения для "Тинькофф" • %s: `, phone))
}

func withAuthorizer(ctx context.Context, askFn jobs.AskFunc) context.Context {
        return tinkoff.WithAuthorizer(ctx, authorizer{askFn: askFn})
}

package tinkoff

import (
        "context"

        "github.com/jfk9w-go/based"
)

type pingingClient struct {
        Client
        pinger based.Goroutine
}

func (c pingingClient) Close() error {
        c.pinger.Cancel()
        return c.pinger.Join(context.Background())
}

package entities

type MultiCardCluster struct {
        Id string `json:"id"`
}

type Card struct {
        AccountId string `json:"-" gorm:"index"`

        Id               string            `json:"id" gorm:"primaryKey"`
        StatusCode       string            `json:"statusCode"`
        Status           string            `json:"status"`
        PinSet           bool              `json:"pinSet"`
        Expiration       Milliseconds      `json:"expiration"`
        CardDesign       string            `json:"cardDesign"`
        Ucid             string            `json:"ucid"`
        PaymentSystem    string            `json:"paymentSystem"`
        FrozenCard       bool              `json:"frozenCard"`
        HasWrongPins     bool              `json:"hasWrongPins"`
        Value            string            `json:"value"`
        IsEmbossed       bool              `json:"isEmbossed"`
        IsVirtual        bool              `json:"isVirtual"`
        CreationDate     Milliseconds      `json:"creationDate"`
        MultiCardCluster *MultiCardCluster `json:"multiCardCluster,omitempty" gorm:"embedded;embeddedPrefix:multi_card_cluster_"`
        Name             string            `json:"name"`
        IsPaymentDevice  bool              `json:"isPaymentDevice"`
        Primary          bool              `json:"primary"`
        CardIssueType    *string           `json:"cardIssueType,omitempty"`
        SharedResourceId *string           `json:"sharedResourceId,omitempty"`
}

type Loyalty struct {
        ProgramName            string   `json:"programName"`
        ProgramCode            string   `json:"programCode"`
        AccountBackgroundColor string   `json:"accountBackgroundColor"`
        CashbackProgram        bool     `json:"cashbackProgram"`
        CoreGroup              string   `json:"coreGroup"`
        LoyaltyPointsId        uint8    `json:"loyaltyPointsId"`
        AccrualBonuses         *float64 `json:"accrualBonuses,omitempty"`
        LinkedBonuses          *string  `json:"linkedBonuses,omitempty"`
        TotalAvailableBonuses  *float64 `json:"totalAvailableBonuses,omitempty"`
        AvailableBonuses       *float64 `json:"availableBonuses,omitempty"`
}

type AccountShared struct {
        Scopes     []string     `json:"scopes"`
        StartDate  Milliseconds `json:"startDate"`
        OwnerName  string       `json:"ownerName"`
        SharStatus string       `json:"sharStatus"`
}

type AccountCreditLimit struct {
        CreditLimitCurrencyCode uint     `json:"-" gorm:"index"`
        CreditLimitCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CreditLimitValue float64 `json:"value"`
}

type AccountMoneyAmount struct {
        MoneyAmountCurrencyCode uint     `json:"-" gorm:"index"`
        MoneyAmountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        MoneyAmountValue float64 `json:"value"`
}

type AccountDebtBalance struct {
        DebtBalanceCurrencyCode uint     `json:"-" gorm:"index"`
        DebtBalanceCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        DebtBalanceValue float64 `json:"value"`
}

type AccountCurrentMinimalPayment struct {
        CurrentMinimalPaymentCurrencyCode uint     `json:"-" gorm:"index"`
        CurrentMinimalPaymentCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CurrentMinimalPaymentValue float64 `json:"value"`
}

type AccountPastDueDebt struct {
        PastDueDebtCurrencyCode uint     `json:"-" gorm:"index"`
        PastDueDebtCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        PastDueDebtValue float64 `json:"value"`
}

type AccountDebtAmount struct {
        DebtAmountCurrencyCode uint     `json:"-" gorm:"index"`
        DebtAmountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        DebtAmountValue float64 `json:"value"`
}

type Account struct {
        UserPhone string `json:"-" gorm:"index"`
        User      User   `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        CurrencyCode *uint     `json:"-" gorm:"index"`
        Currency     *Currency `json:"currency,omitempty" gorm:"constraint:OnDelete:CASCADE"`

        AccountRequisites *AccountRequisites `json:"-"`

        Deleted bool `json:"-" gorm:"index"`

        Id                    string                        `json:"id" gorm:"primaryKey"`
        CreditLimit           *AccountCreditLimit           `json:"creditLimit,omitempty" gorm:"embedded"`
        MoneyAmount           *AccountMoneyAmount           `json:"moneyAmount,omitempty" gorm:"embedded"`
        DebtBalance           *AccountDebtBalance           `json:"debtBalance,omitempty" gorm:"embedded"`
        CurrentMinimalPayment *AccountCurrentMinimalPayment `json:"currentMinimalPayment,omitempty" gorm:"embedded"`
        ClientUnverifiedFlag  *string                       `json:"clientUnverifiedFlag,omitempty"`
        IdentificationState   *string                       `json:"identificationState,omitempty"`
        Status                *string                       `json:"status,omitempty"`
        EmoneyFlag            *bool                         `json:"emoneyFlag,omitempty"`
        NextStatementDate     *Milliseconds                 `json:"nextStatementDate,omitempty"`
        DueDate               *Milliseconds                 `json:"dueDate,omitempty"`
        Cards                 []Card                        `json:"cards,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:AccountId"`
        MultiCardCluster      *MultiCardCluster             `json:"multiCardCluster,omitempty" gorm:"embedded;embeddedPrefix:multi_card_cluster_"`
        LoyaltyId             *string                       `json:"loyaltyId,omitempty"`
        MoneyPotFlag          *bool                         `json:"moneyPotFlag,omitempty"`
        PartNumber            *string                       `json:"partNumber,omitempty"`
        PastDueDebt           *AccountPastDueDebt           `json:"pastDueDebt,omitempty" gorm:"embedded"`
        Name                  string                        `json:"name"`
        AccountType           string                        `json:"accountType"`
        Hidden                bool                          `json:"hidden"`
        SharedByMeFlag        *bool                         `json:"sharedByMeFlag,omitempty"`
        Loyalty               *Loyalty                      `json:"loyalty,omitempty" gorm:"embedded;embeddedPrefix:loyalty_"`
        CreationDate          *Milliseconds                 `json:"creationDate,omitempty"`
        DebtAmount            *AccountDebtAmount            `json:"debtAmount,omitempty" gorm:"embedded"`
        LastStatementDate     *Milliseconds                 `json:"lastStatementDate,omitempty"`
        DueColor              *int                          `json:"dueColor,omitempty"`
        LinkedAccountNumber   *string                       `json:"linkedAccountNumber,omitempty"`
        IsKidsSaving          *bool                         `json:"isKidsSaving,omitempty"`
        IsCrowdfunding        *bool                         `json:"isCrowdfunding,omitempty"`
        //Shared                *AccountShared    `json:"shared,omitempty"`

        FireflyId *string `json:"-" gorm:"<-:false;index"`
}

func (a Account) TableName() string {
        return "accounts"
}

type AccountRequisites struct {
        AccountId string `json:"-" gorm:"primaryKey"`

        CardImage                  string `json:"cardImage"`
        CardLine1                  string `json:"cardLine1"`
        CardLine2                  string `json:"cardLine2"`
        Recipient                  string `json:"recipient"`
        BeneficiaryInfo            string `json:"beneficiaryInfo"`
        BeneficiaryBank            string `json:"beneficiaryBank"`
        RecipientExternalAccount   string `json:"recipientExternalAccount"`
        CorrespondentAccountNumber string `json:"correspondentAccountNumber"`
        BankBik                    string `json:"bankBik"`
        Name                       string `json:"name"`
        Inn                        string `json:"inn"`
        Kpp                        string `json:"kpp"`
}

func (ar AccountRequisites) TableName() string {
        return "account_requisites"
}

package entities

type ClientOfferEssenceMccCode struct {
        ClientOfferEssenceId string `json:"-" gorm:"primaryKey"`
        MccCode              string `json:"-" gorm:"primaryKey"`
}

type ClientOfferEssence struct {
        ClientOfferId string `json:"-" gorm:"index"`

        SpendingCategoryId *string `json:"-" gorm:"index"`
        BrandId            *string `json:"-" gorm:"index"`

        MccCodes []ClientOfferEssenceMccCode `json:"-" gorm:"constraint:OnDelete:CASCADE;foreignKey:ClientOfferEssenceId"`

        Name         string `json:"name"`
        Description  string `json:"description"`
        BusinessType uint   `json:"businessType"`
        IsActive     bool   `json:"isActive"`
        BaseColor    string `json:"baseColor"`
        //MccCodes     []string `json:"mccCodes,omitempty"`
        Logo         string  `json:"logo"`
        ExternalCode string  `json:"externalCode"`
        ExternalId   string  `json:"externalId"`
        Id           string  `json:"id" gorm:"primaryKey"`
        Percent      float64 `json:"percent"`
}

type ClientOfferAttributes struct {
        NotificationFlag bool `json:"notificationFlag"`
}

type ClientOfferAccount struct {
        ClientOfferId string `json:"-" gorm:"primaryKey"`
        AccountId     string `json:"-" gorm:"primaryKey"`
}

type ClientOffer struct {
        UserPhone string `json:"-" gorm:"index"`
        User      User   `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        Accounts []ClientOfferAccount `json:"-" gorm:"constraint:OnDelete:CASCADE;foreignKey:ClientOfferId"`

        TypeCode              string                `json:"typeCode"`
        AvailableEssenceCount uint                  `json:"availableEssenceCount"`
        ActiveTo              Milliseconds          `json:"activeTo"`
        Attributes            ClientOfferAttributes `json:"attributes" gorm:"embedded"`
        ActiveFrom            Milliseconds          `json:"activeFrom"`
        Essences              []ClientOfferEssence  `json:"essences" gorm:"constraint:OnDelete:CASCADE;foreignKey:ClientOfferId"`
        DisplayTo             Milliseconds          `json:"displayTo"`
        DisplayFrom           Milliseconds          `json:"displayFrom"`
        //AccountIds            []string              `json:"accountIds"`
        Id string `json:"id" gorm:"primaryKey"`
}

func (o ClientOffer) TableName() string {
        return "client_offers"
}

package entities

type Currency struct {
        Code    uint   `json:"code" gorm:"primaryKey;autoIncrement:false"`
        Name    string `json:"name" gorm:"index"`
        StrCode string `json:"strCode"`

        FireflyId *string `json:"-" gorm:"<-:false;index"`
}

func (c Currency) TableName() string {
        return "currencies"
}

package entities

import (
        "database/sql/driver"
        "time"

        "github.com/jfk9w-go/tinkoff-api/v2"
        "github.com/pkg/errors"
)

type Milliseconds struct {
        tinkoff.Milliseconds
}

func (ms Milliseconds) GormDataType() string {
        return "time"
}

func (ms Milliseconds) Value() (driver.Value, error) {
        return ms.Time(), nil
}

func (ms *Milliseconds) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                ms.Milliseconds = tinkoff.Milliseconds(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type ReceiptDateTime struct {
        tinkoff.ReceiptDateTime
}

func (dt ReceiptDateTime) GormDataType() string {
        return "time"
}

func (dt ReceiptDateTime) Value() (driver.Value, error) {
        return dt.Time(), nil
}

func (dt *ReceiptDateTime) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                dt.ReceiptDateTime = tinkoff.ReceiptDateTime(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type DateTimeMilliOffset struct {
        tinkoff.DateTimeMilliOffset
}

func (dt DateTimeMilliOffset) GormDataType() string {
        return "time"
}

func (dt DateTimeMilliOffset) Value() (driver.Value, error) {
        return dt.Time(), nil
}

func (dt *DateTimeMilliOffset) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                dt.DateTimeMilliOffset = tinkoff.DateTimeMilliOffset(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type DateTime struct {
        tinkoff.DateTime
}

func (dt DateTime) GormDataType() string {
        return "time"
}

func (dt DateTime) Value() (driver.Value, error) {
        return dt.Time(), nil
}

func (dt *DateTime) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                dt.DateTime = tinkoff.DateTime(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type Date struct {
        tinkoff.Date
}

func (d Date) GormDataType() string {
        return "date"
}

func (d Date) Value() (driver.Value, error) {
        return d.Time(), nil
}

func (d *Date) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                d.Date = tinkoff.Date(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

type InvestCandleDate struct {
        tinkoff.InvestCandleDate
}

func (d InvestCandleDate) GormDataType() string {
        return "time"
}

func (d InvestCandleDate) Value() (driver.Value, error) {
        return d.Time(), nil
}

func (d *InvestCandleDate) Scan(value any) error {
        if value, ok := value.(time.Time); ok {
                d.InvestCandleDate = tinkoff.InvestCandleDate(value)
                return nil
        }

        return errors.Errorf("expected time.Time, got %T", value)
}

package entities

type InvestOperationType struct {
        Deleted bool `json:"-" gorm:"index"`

        Category      string `json:"category"`
        OperationName string `json:"operationName"`
        OperationType string `json:"operationType" gorm:"primaryKey"`
}

func (t InvestOperationType) TableName() string {
        return "invest_operation_types"
}

type InvestAmount struct {
        Currency string  `json:"currency"`
        Value    float64 `json:"value"`
}

type InvestTotals struct {
        ExpectedYield                InvestAmount `json:"expectedYield" gorm:"embedded;embeddedPrefix:expected_yield_"`
        ExpectedYieldRelative        float64      `json:"expectedYieldRelative"`
        ExpectedYieldPerDay          InvestAmount `json:"expectedYieldPerDay" gorm:"embedded;embeddedPrefix:expected_yield_per_day_"`
        ExpectedYieldPerDayRelative  float64      `json:"expectedYieldPerDayRelative"`
        ExpectedAverageYield         InvestAmount `json:"expectedAverageYield" gorm:"embedded;embeddedPrefix:expected_average_yield_"`
        ExpectedAverageYieldRelative float64      `json:"expectedAverageYieldRelative"`
        TotalAmount                  InvestAmount `json:"totalAmount" gorm:"embedded;embeddedPrefix:total_amount_"`
}

type InvestAccount struct {
        UserPhone string `json:"-" gorm:"index"`
        User      User   `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        Deleted bool `json:"-" gorm:"index"`

        Id            string `json:"brokerAccountId" gorm:"primaryKey"`
        Type          string `json:"brokerAccountType"`
        Name          string `json:"name"`
        OpenedDate    Date   `json:"openedDate"`
        Order         int    `json:"order"`
        Status        string `json:"status"`
        IsVisible     bool   `json:"isVisible"`
        Organization  string `json:"organization"`
        BuyByDefault  bool   `json:"buyByDefault"`
        MarginEnabled bool   `json:"marginEnabled"`
        AutoApp       bool   `json:"autoApp"`

        InvestTotals `gorm:"embedded"`
}

func (a InvestAccount) TableName() string {
        return "invest_accounts"
}

type Trade struct {
        InvestOperationInternalId string `json:"-" gorm:"primaryKey"`
        DbIdx                     int    `json:"dbIdx" gorm:"primaryKey"`

        Date          DateTimeMilliOffset `json:"date"`
        Num           string              `json:"num"`
        Price         InvestAmount        `json:"price" gorm:"embedded;embeddedPrefix:price_"`
        Quantity      int                 `json:"quantity"`
        Yield         *InvestAmount       `json:"yield,omitempty" gorm:"embedded;embeddedPrefix:yield_"`
        YieldRelative *float64            `json:"yieldRelative,omitempty"`
}

type TradesInfo struct {
        Trades     []Trade `json:"trades" gorm:"constraint:OnDelete:CASCADE;foreignKey:InvestOperationInternalId"`
        TradesSize int     `json:"tradesSize"`
}

type InvestChildOperation struct {
        InvestOperationInternalId string `json:"-" gorm:"primaryKey"`
        DbIdx                     int    `json:"dbIdx" gorm:"primaryKey"`

        Currency       string       `json:"currency"`
        Id             string       `json:"id"`
        InstrumentType string       `json:"instrumentType"`
        InstrumentUid  string       `json:"instrumentUid"`
        LogoName       string       `json:"logoName"`
        Payment        InvestAmount `json:"payment" gorm:"embedded;embeddedPrefix:payment_"`
        ShowName       string       `json:"showName"`
        Ticker         string       `json:"ticker"`
        Type           string       `json:"type"`
        Value          float64      `json:"value"`
}

type InvestOperation struct {
        InvestAccountId string        `json:"brokerAccountId" gorm:"index"`
        InvestAccount   InvestAccount `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        AssetUid                      *string                `json:"assetUid,omitempty"`
        BestExecuted                  bool                   `json:"bestExecuted"`
        ClassCode                     *string                `json:"classCode,omitempty"`
        Cursor                        string                 `json:"cursor"`
        Date                          DateTimeMilliOffset    `json:"date"`
        Description                   string                 `json:"description"`
        Id                            *string                `json:"id,omitempty"`
        InstrumentType                *string                `json:"instrumentType,omitempty"`
        InstrumentUid                 *string                `json:"instrumentUid,omitempty"`
        InternalId                    string                 `json:"internalId" gorm:"primaryKey"`
        IsBlockedTradeClearingAccount *bool                  `json:"isBlockedTradeClearingAccount,omitempty"`
        Isin                          *string                `json:"isin,omitempty"`
        LogoName                      *string                `json:"logoName,omitempty"`
        Name                          *string                `json:"name,omitempty"`
        Payment                       InvestAmount           `json:"payment" gorm:"embedded;embeddedPrefix:payment_"`
        PaymentEur                    InvestAmount           `json:"paymentEur" gorm:"embedded;embeddedPrefix:payment_eur_"`
        PaymentRub                    InvestAmount           `json:"paymentRub" gorm:"embedded;embeddedPrefix:payment_rub_"`
        PaymentUsd                    InvestAmount           `json:"paymentUsd" gorm:"embedded;embeddedPrefix:payment_usd_"`
        PositionUid                   *string                `json:"positionUid,omitempty"`
        ShortDescription              *string                `json:"shortDescription,omitempty"`
        ShowName                      *string                `json:"showName,omitempty"`
        Status                        string                 `json:"status"`
        TextColor                     *string                `json:"textColor,omitempty"`
        Ticker                        *string                `json:"ticker,omitempty"`
        Type                          string                 `json:"type"`
        AccountId                     *string                `json:"accountId,omitempty"`
        DoneRest                      *int                   `json:"doneRest,omitempty"`
        Price                         *InvestAmount          `json:"price,omitempty" gorm:"embedded;embeddedPrefix:price_"`
        Quantity                      *int                   `json:"quantity,omitempty"`
        TradesInfo                    *TradesInfo            `json:"tradesInfo,omitempty" gorm:"embedded"`
        ParentOperationId             *string                `json:"parentOperationId,omitempty"`
        ChildOperations               []InvestChildOperation `json:"childOperations,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:InvestOperationInternalId"`
        Commission                    *InvestAmount          `json:"commission,omitempty" gorm:"embedded;embeddedPrefix:commission_"`
        Yield                         *InvestAmount          `json:"yield,omitempty" gorm:"embedded;embeddedPrefix:yield_"`
        YieldRelative                 *float64               `json:"yieldRelative,omitempty"`
        CancelReason                  *string                `json:"cancelReason,omitempty"`
        QuantityRest                  *int                   `json:"quantityRest,omitempty"`
        WithdrawDateTime              *DateTime              `json:"withdrawDateTime,omitempty"`
}

func (o InvestOperation) TableName() string {
        return "invest_operations"
}

type InvestCandle struct {
        Ticker string `json:"-" gorm:"primaryKey"`

        O    float64          `json:"o"`
        C    float64          `json:"c"`
        H    float64          `json:"h"`
        L    float64          `json:"l"`
        V    float64          `json:"v"`
        Date InvestCandleDate `json:"date" gorm:"primaryKey"`
}

func (c InvestCandle) TableName() string {
        return "invest_candles"
}

package entities

import "encoding/json"

type Category struct {
        Id   string `json:"id" gorm:"primaryKey"`
        Name string `json:"name" gorm:"index"`
}

type Location struct {
        OperationId string `json:"-" gorm:"primaryKey"`
        DbIdx       int    `json:"dbIdx" gorm:"primaryKey"`

        Latitude  float64 `json:"latitude"`
        Longitude float64 `json:"longitude"`
}

type LoyaltyAmount struct {
        Value               float64 `json:"value"`
        LoyaltyProgramId    string  `json:"loyaltyProgramId"`
        Loyalty             string  `json:"loyalty"`
        Name                string  `json:"name"`
        LoyaltySteps        uint8   `json:"loyaltySteps"`
        LoyaltyPointsId     uint8   `json:"loyaltyPointsId"`
        LoyaltyPointsName   string  `json:"loyaltyPointsName"`
        LoyaltyImagine      bool    `json:"loyaltyImagine"`
        PartialCompensation bool    `json:"partialCompensation"`
}

type LoyaltyBonus struct {
        OperationId string `json:"-" gorm:"primaryKey"`
        DbIdx       int    `json:"dbIdx" gorm:"primaryKey"`

        Description      string        `json:"description"`
        Icon             string        `json:"icon"`
        LoyaltyType      string        `json:"loyaltyType"`
        Amount           LoyaltyAmount `json:"amount" gorm:"embedded"`
        CompensationType string        `json:"compensationType"`
}

type Region struct {
        Country    *string `json:"country,omitempty"`
        City       *string `json:"city,omitempty"`
        Address    *string `json:"address,omitempty"`
        Zip        *string `json:"zip,omitempty"`
        AddressRus *string `json:"addressRus,omitempty"`
}

type Merchant struct {
        Name   string  `json:"name" gorm:"index"`
        Region *Region `json:"region,omitempty" gorm:"embedded"`
}

type SpendingCategory struct {
        Id   string `json:"id" gorm:"primaryKey"`
        Name string `json:"name" gorm:"index"`

        FireflyId *string `json:"-" gorm:"<-:false;index"`
}

func (sc SpendingCategory) TableName() string {
        return "spending_categories"
}

type Brand struct {
        Name          string  `json:"name" gorm:"index"`
        BaseTextColor *string `json:"baseTextColor,omitempty"`
        Logo          *string `json:"logo,omitempty"`
        Id            string  `json:"id" gorm:"primaryKey"`
        RoundedLogo   bool    `json:"roundedLogo"`
        BaseColor     *string `json:"baseColor,omitempty"`
        LogoFile      *string `json:"logoFile,omitempty"`
        Link          *string `json:"link,omitempty"`
        SvgLogoFile   *string `json:"svgLogoFile"`
}

type AdditionalInfo struct {
        OperationId string `json:"-" gorm:"primaryKey"`
        DbIdx       int    `json:"dbIdx" gorm:"primaryKey"`

        FieldName  string `json:"fieldName"`
        FieldValue string `json:"fieldValue"`
}

type LoyaltyPaymentAmount struct {
        LoyaltyAmount `gorm:"embedded"`
        Price         float64 `json:"price"`
}

type LoyaltyPayment struct {
        OperationId string `json:"-" gorm:"primaryKey"`
        DbIdx       int    `json:"dbIdx" gorm:"primaryKey"`

        Amount   LoyaltyPaymentAmount `json:"amount" gorm:"embedded"`
        Status   string               `json:"status"`
        SoldTime *Milliseconds        `json:"soldTime"`
}

type LoyaltyBonusSummary struct {
        Amount float64 `json:"amount"`
}

type PaymentFeeAmount struct {
        FeeAmountCurrencyCode uint     `json:"-" gorm:"index"`
        FeeAmountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        FeeAmountValue float64 `json:"value"`
}

type PaymentFieldValue struct {
        PaymentId string `gorm:"primaryKey"`
        Key       string `gorm:"primaryKey"`
        Value     string
}

type PaymentFieldsValues []PaymentFieldValue

func (fvs PaymentFieldsValues) MarshalJSON() ([]byte, error) {
        values := make(map[string]string)
        for _, fv := range fvs {
                values[fv.Key] = fv.Value
        }

        return json.Marshal(values)
}

func (fvs *PaymentFieldsValues) UnmarshalJSON(data []byte) error {
        var values map[string]string
        if err := json.Unmarshal(data, &values); err != nil {
                return err
        }

        for key, value := range values {
                *fvs = append(*fvs, PaymentFieldValue{
                        Key:   key,
                        Value: value,
                })
        }

        return nil
}

type Payment struct {
        SourceIsQr      bool                `json:"sourceIsQr"`
        BankAccountId   string              `json:"bankAccountId" gorm:"index"`
        PaymentId       string              `json:"paymentId" gorm:"primaryKey"`
        ProviderGroupId *string             `json:"providerGroupId,omitempty"`
        PaymentType     string              `json:"paymentType"`
        FeeAmount       *PaymentFeeAmount   `json:"feeAmount,omitempty" gorm:"embedded"`
        ProviderId      string              `json:"providerId"`
        HasPaymentOrder bool                `json:"hasPaymentOrder"`
        Comment         *string             `json:"comment,omitempty"`
        IsQrPayment     bool                `json:"isQrPayment"`
        FieldsValues    PaymentFieldsValues `json:"fieldsValues"`
        //Repeatable         bool    `json:"repeatable"`        // отличается у входящих и исходящих платежей
        CardNumber         string  `json:"cardNumber"`
        TemplateId         *string `json:"templateId,omitempty"`
        TemplateIsFavorite *bool   `json:"templateIsFavorite,omitempty"`
}

type Subgroup struct {
        Id   string  `json:"id" gorm:"primaryKey"`
        Name *string `json:"name,omitempty" gorm:"index"`
}

type OperationCashbackAmount struct {
        CashbackCurrencyCode uint     `json:"-" gorm:"index"`
        CashbackCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CashbackValue float64 `json:"value"`
}

type OperationAmount struct {
        CurrencyCode uint     `json:"-" gorm:"index"`
        Currency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        Value float64 `json:"value"`
}

type OperationAccountAmount struct {
        AccountCurrencyCode uint     `json:"-" gorm:"index"`
        AccountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        AccountValue float64 `json:"value"`
}

type Operation struct {
        AccountId string  `json:"account" gorm:"index"`
        Account   Account `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        BrandId *string `json:"-" gorm:"index"`
        Brand   *Brand  `json:"brand,omitempty" gorm:"constraint:OnDelete:CASCADE"`

        SpendingCategoryId string           `json:"-" gorm:"index"`
        SpendingCategory   SpendingCategory `json:"spendingCategory" gorm:"constraint:OnDelete:CASCADE"`

        CategoryId string   `json:"-" gorm:"index"`
        Category   Category `json:"category" gorm:"constraint:OnDelete:CASCADE"`

        SubgroupId *string   `json:"-" gorm:"index"`
        Subgroup   *Subgroup `json:"subgroup,omitempty" gorm:"constraint:OnDelete:CASCADE"`

        PaymentId *string  `json:"-" gorm:"index"`
        Payment   *Payment `json:"payment,omitempty" gorm:"constraint:OnDelete:CASCADE"`

        IsDispute              bool                    `json:"isDispute"`
        IsOffline              bool                    `json:"isOffline"`
        HasStatement           bool                    `json:"hasStatement"`
        IsSuspicious           bool                    `json:"isSuspicious"`
        AuthorizationId        *string                 `json:"authorizationId,omitempty"`
        IsInner                bool                    `json:"isInner" gorm:"index"`
        Id                     string                  `json:"id" gorm:"primaryKey"`
        Status                 string                  `json:"status" gorm:"index"`
        OperationTransferred   bool                    `json:"operationTransferred"`
        IdSourceType           string                  `json:"idSourceType"`
        HasShoppingReceipt     *bool                   `json:"hasShoppingReceipt,omitempty" gorm:"index"`
        Type                   string                  `json:"type" gorm:"index"`
        Locations              []Location              `json:"locations,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:OperationId"`
        LoyaltyBonus           []LoyaltyBonus          `json:"loyaltyBonus,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:OperationId"`
        CashbackAmount         OperationCashbackAmount `json:"cashbackAmount" gorm:"embedded"`
        AuthMessage            *string                 `json:"authMessage,omitempty"`
        Description            string                  `json:"description"`
        IsTemplatable          bool                    `json:"isTemplatable"`
        Cashback               float64                 `json:"cashback"`
        Amount                 OperationAmount         `json:"amount" gorm:"embedded"`
        OperationTime          Milliseconds            `json:"operationTime" gorm:"index"`
        IsHce                  bool                    `json:"isHce"`
        Mcc                    uint                    `json:"mcc"`
        AdditionalInfo         []AdditionalInfo        `json:"additionalInfo,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:OperationId"`
        VirtualPaymentType     uint8                   `json:"virtualPaymentType"`
        Ucid                   *string                 `json:"ucid,omitempty"`
        Merchant               *Merchant               `json:"merchant,omitempty" gorm:"embedded;embeddedPrefix:merchant_"`
        Card                   *string                 `json:"card,omitempty" gorm:"index"`
        LoyaltyPayment         []LoyaltyPayment        `json:"loyaltyPayment,omitempty" gorm:"constraint:OnDelete:CASCADE;foreignKey:OperationId"`
        TrancheCreationAllowed bool                    `json:"trancheCreationAllowed"`
        Group                  *string                 `json:"group,omitempty"`
        MccString              string                  `json:"mccString"`
        CardPresent            bool                    `json:"cardPresent"`
        IsExternalCard         bool                    `json:"isExternalCard"`
        CardNumber             *string                 `json:"cardNumber,omitempty"`
        AccountAmount          OperationAccountAmount  `json:"accountAmount" gorm:"embedded"`
        LoyaltyBonusSummary    *LoyaltyBonusSummary    `json:"loyaltyBonusSummary,omitempty" gorm:"embedded;embeddedPrefix:loyalty_bonus_summary_"`
        TypeSerno              *uint                   `json:"typeSerno"`
        OperationPaymentType   *string                 `json:"operationPaymentType,omitempty"`
        DebitingTime           *Milliseconds           `json:"debitingTime,omitempty" gorm:"index"`
        PosId                  *string                 `json:"posId,omitempty"`
        Subcategory            *string                 `json:"subcategory,omitempty" gorm:"index"`
        SenderAgreement        *string                 `json:"senderAgreement,omitempty"`
        PointOfSaleId          *uint64                 `json:"pointOfSaleId,omitempty"`
        Compensation           *string                 `json:"compensation,omitempty"`
        InstallmentStatus      *string                 `json:"installmentStatus,omitempty"`
        SenderDetails          *string                 `json:"senderDetails,omitempty"`
        PartnerType            *string                 `json:"partnerType,omitempty"`
        Nomination             *string                 `json:"nomination,omitempty"`
        Message                *string                 `json:"message,omitempty"`
        TrancheId              *string                 `json:"trancheId,omitempty"`

        FireflyId *string `json:"-" gorm:"<-:false;index"`
}

func (o Operation) TableName() string {
        return "operations"
}

package entities

type ReceiptItem struct {
        OperationId string `json:"-" gorm:"primaryKey"`
        DbIdx       int    `json:"dbIdx" gorm:"primaryKey"`

        Name     string   `json:"name" gorm:"index"`
        Price    float64  `json:"price"`
        Sum      float64  `json:"sum"`
        Quantity float64  `json:"quantity"`
        NdsRate  *uint8   `json:"ndsRate"`
        Nds      *uint8   `json:"nds"`
        Nds10    *float64 `json:"nds10,omitempty"`
        Nds18    *float64 `json:"nds18,omitempty"`
        BrandId  *uint64  `json:"brand_id,omitempty"`
        GoodId   *uint64  `json:"good_id,omitempty"`
}

type Receipt struct {
        OperationId string    `json:"-" gorm:"primaryKey"`
        Operation   Operation `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        RetailPlace             *string         `json:"retailPlace,omitempty"`
        RetailPlaceAddress      *string         `json:"retailPlaceAddress,omitempty"`
        CreditSum               *float64        `json:"creditSum,omitempty"`
        ProvisionSum            *float64        `json:"provisionSum,omitempty"`
        FiscalDriveNumber       *uint64         `json:"fiscalDriveNumber,omitempty"`
        OperationType           uint8           `json:"operationType"`
        CashTotalSum            float64         `json:"cashTotalSum"`
        ShiftNumber             uint            `json:"shiftNumber"`
        KktRegId                string          `json:"kktRegId"`
        Items                   []ReceiptItem   `json:"items" gorm:"constraint:OnDelete:CASCADE;foreignKey:OperationId"`
        TotalSum                float64         `json:"totalSum"`
        EcashTotalSum           float64         `json:"ecashTotalSum"`
        Nds10                   *float64        `json:"nds10,omitempty"`
        Nds18                   *float64        `json:"nds18,omitempty"`
        UserInn                 string          `json:"userInn"`
        DateTime                ReceiptDateTime `json:"dateTime"`
        TaxationType            uint8           `json:"taxationType"`
        PrepaidSum              *float64        `json:"prepaidSum,omitempty"`
        FiscalSign              uint64          `json:"fiscalSign"`
        RequestNumber           uint            `json:"requestNumber"`
        Operator                *string         `json:"operator,omitempty"`
        AppliedTaxationType     uint8           `json:"appliedTaxationType"`
        FiscalDocumentNumber    uint64          `json:"fiscalDocumentNumber"`
        User                    *string         `json:"user,omitempty"`
        FiscalDriveNumberString string          `json:"fiscalDriveNumberString"`
}

func (r Receipt) TableName() string {
        return "receipts"
}

package entities

type StatementPeriod struct {
        Start Milliseconds `json:"start"`
        End   Milliseconds `json:"end"`
}

type StatementOverdraftFee struct {
        OverdraftFeeCurrencyCode uint     `json:"-" gorm:"index"`
        OverdraftFeeCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        OverdraftFeeValue float64 `json:"value"`
}

type StatementExpense struct {
        ExpenseCurrencyCode uint     `json:"-" gorm:"index"`
        ExpenseCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        ExpenseValue float64 `json:"value"`
}

type StatementOverLimitDebt struct {
        OverLimitDebtCurrencyCode uint     `json:"-" gorm:"index"`
        OverLimitDebtCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        OverLimitDebtValue float64 `json:"value"`
}

type StatementPeriodEndBalance struct {
        PeriodEndBalanceCurrencyCode uint     `json:"-" gorm:"index"`
        PeriodEndBalanceCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        PeriodEndBalanceValue float64 `json:"value"`
}

type StatementArrestAmount struct {
        ArrestAmountCurrencyCode uint     `json:"-" gorm:"index"`
        ArrestAmountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        ArrestAmountValue float64 `json:"value"`
}

type StatementOtherBonus struct {
        OtherBonusCurrencyCode uint     `json:"-" gorm:"index"`
        OtherBonusCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        OtherBonusValue float64 `json:"value"`
}

type StatementCreditLimit struct {
        CreditLimitCurrencyCode uint     `json:"-" gorm:"index"`
        CreditLimitCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CreditLimitValue float64 `json:"value"`
}

type StatementTranchesMonthlyPayment struct {
        TranchesMonthlyPaymentCurrencyCode uint     `json:"-" gorm:"index"`
        TranchesMonthlyPaymentCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        TranchesMonthlyPaymentValue float64 `json:"value"`
}

type StatementBilledDebt struct {
        BilledDebtCurrencyCode uint     `json:"-" gorm:"index"`
        BilledDebtCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        BilledDebtValue float64 `json:"value"`
}

type StatementCashback struct {
        CashbackCurrencyCode uint     `json:"-" gorm:"index"`
        CashbackCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CashbackValue float64 `json:"value"`
}

type StatementBalance struct {
        BalanceCurrencyCode uint     `json:"-" gorm:"index"`
        BalanceCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        BalanceValue float64 `json:"value"`
}

type StatementHighCashback struct {
        HighCashbackCurrencyCode uint     `json:"-" gorm:"index"`
        HighCashbackCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        HighCashbackValue float64 `json:"value"`
}

type StatementPeriodStartBalance struct {
        PeriodStartBalanceCurrencyCode uint     `json:"-" gorm:"index"`
        PeriodStartBalanceCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        PeriodStartBalanceValue float64 `json:"value"`
}

type StatementLowCashback struct {
        LowCashbackCurrencyCode uint     `json:"-" gorm:"index"`
        LowCashbackCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        LowCashbackValue float64 `json:"value"`
}

type StatementAvailableLimit struct {
        AvailableLimitCurrencyCode uint     `json:"-" gorm:"index"`
        AvailableLimitCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        AvailableLimitValue float64 `json:"value"`
}

type StatementInterestBonus struct {
        InterestBonusCurrencyCode uint     `json:"-" gorm:"index"`
        InterestBonusCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        InterestBonusValue float64 `json:"value"`
}

type StatementInterest struct {
        InterestCurrencyCode uint     `json:"-" gorm:"index"`
        InterestCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        InterestValue float64 `json:"value"`
}

type StatementIncome struct {
        IncomeCurrencyCode uint     `json:"-" gorm:"index"`
        IncomeCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        IncomeValue float64 `json:"value"`
}

type StatementCreditBonus struct {
        CreditBonusCurrencyCode uint     `json:"-" gorm:"index"`
        CreditBonusCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        CreditBonusValue float64 `json:"value"`
}

type StatementOtherCashback struct {
        OtherCashbackCurrencyCode uint     `json:"-" gorm:"index"`
        OtherCashbackCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        OtherCashbackValue float64 `json:"value"`
}

type StatementMinimalPaymentAmount struct {
        MinimalPaymentAmountCurrencyCode uint     `json:"-" gorm:"index"`
        MinimalPaymentAmountCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        MinimalPaymentAmountValue float64 `json:"value"`
}

type StatementPastDueDebt struct {
        PastDueDebtCurrencyCode uint     `json:"-" gorm:"index"`
        PastDueDebtCurrency     Currency `json:"currency" gorm:"constraint:OnDelete:CASCADE"`

        PastDueDebtValue float64 `json:"value"`
}

type Statement struct {
        AccountId string  `json:"-" gorm:"index"`
        Account   Account `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        OverdraftFee           *StatementOverdraftFee           `json:"overdraftFee,omitempty" gorm:"embedded"`
        Expense                StatementExpense                 `json:"expense" gorm:"embedded"`
        OverLimitDebt          *StatementOverLimitDebt          `json:"overLimitDebt,omitempty" gorm:"embedded"`
        PeriodEndBalance       StatementPeriodEndBalance        `json:"periodEndBalance" gorm:"embedded"`
        ArrestAmount           *StatementArrestAmount           `json:"arrestAmount,omitempty" gorm:"embedded"`
        OtherBonus             *StatementOtherBonus             `json:"otherBonus,omitempty" gorm:"embedded"`
        CreditLimit            *StatementCreditLimit            `json:"creditLimit,omitempty" gorm:"embedded"`
        TranchesMonthlyPayment *StatementTranchesMonthlyPayment `json:"tranchesMonthlyPayment,omitempty" gorm:"embedded"`
        BilledDebt             *StatementBilledDebt             `json:"billedDebt,omitempty" gorm:"embedded"`
        Cashback               *StatementCashback               `json:"cashback" gorm:"embedded"`
        Balance                StatementBalance                 `json:"balance" gorm:"embedded"`
        HighCashback           *StatementHighCashback           `json:"highCashback,omitempty" gorm:"embedded"`
        PeriodStartBalance     StatementPeriodStartBalance      `json:"periodStartBalance" gorm:"embedded"`
        LowCashback            *StatementLowCashback            `json:"lowCashback,omitempty" gorm:"embedded"`
        AvailableLimit         *StatementAvailableLimit         `json:"availableLimit,omitempty" gorm:"embedded"`
        Id                     string                           `json:"id" gorm:"primaryKey"`
        InterestBonus          *StatementInterestBonus          `json:"interestBonus,omitempty" gorm:"embedded"`
        Interest               *StatementInterest               `json:"interest" gorm:"embedded"`
        Date                   Milliseconds                     `json:"date" gorm:"index"`
        Income                 StatementIncome                  `json:"income" gorm:"embedded"`
        CreditBonus            *StatementCreditBonus            `json:"creditBonus,omitempty" gorm:"embedded"`
        LastPaymentDate        *Milliseconds                    `json:"lastPaymentDate,omitempty"`
        OtherCashback          *StatementOtherCashback          `json:"otherCashback,omitempty" gorm:"embedded"`
        MinimalPaymentAmount   *StatementMinimalPaymentAmount   `json:"minimalPaymentAmount,omitempty" gorm:"embedded"`
        PastDueDebt            *StatementPastDueDebt            `json:"pastDueDebt,omitempty" gorm:"embedded"`
        Period                 StatementPeriod                  `json:"period" gorm:"embedded;embeddedPrefix:period_"`
        NoOverdue              *bool                            `json:"noOverdue,omitempty"`
        Repaid                 *string                          `json:"repaid,omitempty"`
}

func (s Statement) TableName() string {
        return "statements"
}

package entities

type User struct {
        Phone string `gorm:"primaryKey"`
        Name  string `gorm:"index"`
}

func (u User) TableName() string {
        return "users"
}

type Session struct {
        UserPhone string `json:"-" gorm:"primaryKey"`
        User      User   `json:"-" gorm:"constraint:OnDelete:CASCADE"`

        ID string
}

package loaders

import (
        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type accountRequisites struct {
        accountId string
}

func (l accountRequisites) TableName() string {
        return new(AccountRequisites).TableName()
}

func (l accountRequisites) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        ctx = ctx.With("account_id", l.accountId)

        out, err := client.AccountRequisites(ctx, &tinkoff.AccountRequisitesIn{Account: l.accountId})
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if out == nil {
                return
        }

        entity, err := database.ToViaJSON[AccountRequisites](out)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        entity.AccountId = l.accountId

        if err := db.WithContext(ctx).
                Upsert(entity).
                Error; ctx.Error(&errs, err, "failed to update entity in db") {
                return
        }

        ctx.Info("updated entity in db")
        return
}

package loaders

import (
        "time"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

var supportedAccountTypes = map[string]bool{
        "Current": true,
        "Credit":  true,
        "Saving":  true,
}

type Accounts struct {
        Phone        string
        BatchSize    int
        Overlap      time.Duration
        WithReceipts bool
}

func (l Accounts) TableName() string {
        return new(Account).TableName()
}

func (l Accounts) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        out, err := client.AccountsLightIb(ctx)
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out) == 0 {
                return
        }

        var (
                entities []Account
                ids      []string
        )

        for _, out := range out {
                ctx := ctx.With("account_id", out.Id)
                if !supportedAccountTypes[out.AccountType] {
                        ctx.Debug("account type is not supported", "account_type", out.AccountType)
                        continue
                }

                entity, err := database.ToViaJSON[Account](out)
                if ctx.Error(&errs, err, "entity conversion failed") {
                        return
                }

                entity.UserPhone = l.Phone
                entities = append(entities, entity)
                ids = append(ids, out.Id)
        }

        if errs = db.WithContext(ctx).Transaction(func(tx database.DB) (errs error) {
                if err := tx.Upsert(entities).Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                if err := tx.Model(new(Account)).
                        Where("user_phone = ? and id not in ?", l.Phone, ids).
                        Update("deleted", true).
                        Error; ctx.Error(&errs, err, "failed to mark deleted entities in db") {
                        return
                }

                return
        }); errs != nil {
                return
        }

        ctx.Info("updated entities in db", "count", len(ids))

        for _, id := range ids {
                ls = append(ls,
                        accountRequisites{accountId: id},
                        statements{accountId: id, batchSize: l.BatchSize},
                        operations{accountId: id, batchSize: l.BatchSize, overlap: l.Overlap})
        }

        if l.WithReceipts {
                ls = append(ls, receipts{phone: l.Phone, batchSize: l.BatchSize})
        }

        return
}

package loaders

import (
        "github.com/AlekSi/pointer"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type ClientOffers struct {
        Phone     string
        BatchSize int
}

func (l ClientOffers) TableName() string {
        return new(ClientOffer).TableName()
}

func (l ClientOffers) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        out, err := client.ClientOfferEssences(ctx)
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out) == 0 {
                return
        }

        entities, err := database.ToViaJSON[[]ClientOffer](out)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        for i := range out {
                entity := &entities[i]
                entity.UserPhone = l.Phone
                for _, accountId := range out[i].AccountIds {
                        entity.Accounts = append(entity.Accounts, ClientOfferAccount{AccountId: accountId})
                        for j := range out[i].Essences {
                                entity := &entity.Essences[j]
                                switch entity.ExternalCode {
                                case "CATEGORY":
                                        entity.SpendingCategoryId = pointer.To(entity.ExternalId)
                                case "BRAND":
                                        entity.BrandId = pointer.To(entity.ExternalId)
                                }

                                for _, mccCode := range out[i].Essences[j].MccCodes {
                                        entity.MccCodes = append(entity.MccCodes, ClientOfferEssenceMccCode{
                                                MccCode: mccCode,
                                        })
                                }
                        }
                }
        }

        if err := db.WithContext(ctx).
                UpsertInBatches(entities, l.BatchSize).
                Error; ctx.Error(&errs, err, "failed to update entities in db") {
                return
        }

        ctx.Info("updated entities in db", "count", len(entities))
        return
}

package loaders

import (
        "time"

        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type InvestAccounts struct {
        Phone     string
        BatchSize int
        Overlap   time.Duration
        Now       time.Time
}

func (l InvestAccounts) TableName() string {
        return new(InvestAccount).TableName()
}

func (l InvestAccounts) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        out, err := client.InvestAccounts(ctx, &tinkoff.InvestAccountsIn{Currency: "RUB"})
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out.Accounts.List) == 0 {
                return
        }

        entities, err := database.ToViaJSON[[]InvestAccount](out.Accounts.List)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        var ids []string
        for i := range entities {
                entity := &entities[i]
                entity.UserPhone = l.Phone
                ids = append(ids, entity.Id)
        }

        if errs = db.WithContext(ctx).Transaction(func(tx database.DB) (errs error) {
                if err := tx.Upsert(entities).Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                if err := tx.Model(new(InvestAccount)).
                        Where("user_phone = ? and id not in ?", l.Phone, ids).
                        Update("deleted", true).
                        Error; ctx.Error(&errs, err, "failed to mark deleted entities in db") {
                        return
                }

                return
        }); errs != nil {
                return
        }

        ctx.Info("updated entities in db", "count", len(ids))

        for _, id := range ids {
                ls = append(ls, investOperations{
                        accountId: id,
                        batchSize: l.BatchSize,
                        overlap:   l.Overlap,
                        now:       l.Now,
                })
        }

        return
}

package loaders

import (
        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type InvestOperationTypes struct {
        BatchSize int
}

func (l InvestOperationTypes) TableName() string {
        return new(InvestOperationType).TableName()
}

func (l InvestOperationTypes) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        out, err := client.InvestOperationTypes(ctx)
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out.OperationsTypes) == 0 {
                return
        }

        var (
                uniqueTypes = make(map[string]bool)
                entities    []InvestOperationType
                types       []string
        )

        for _, out := range out.OperationsTypes {
                ctx := ctx.With("operation_type", out.OperationType)

                if uniqueTypes[out.OperationType] {
                        ctx.Debug("skipping duplicate")
                        continue
                }

                entity, err := database.ToViaJSON[InvestOperationType](out)
                if ctx.Error(&errs, err, "entity conversion failed") {
                        return
                }

                uniqueTypes[out.OperationType] = true
                entities = append(entities, entity)
                types = append(types, out.OperationType)
        }

        if errs = db.WithContext(ctx).Transaction(func(tx database.DB) (errs error) {
                if err := tx.UpsertInBatches(entities, l.BatchSize).Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                if err := tx.Model(new(InvestOperationType)).
                        Where("operation_type not in ?", types).
                        Update("deleted", true).
                        Error; ctx.Error(&errs, err, "failed to mark deleted entities in db") {
                        return
                }

                return
        }); errs != nil {
                return
        }

        ctx.Info("updated entities in db", "count", len(entities))
        return
}

package loaders

import (
        "database/sql"
        "time"

        "github.com/AlekSi/pointer"
        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type investOperations struct {
        accountId string
        batchSize int
        overlap   time.Duration
        now       time.Time
}

func (l investOperations) TableName() string {
        return new(InvestOperation).TableName()
}

func (l investOperations) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        ctx = ctx.With("account_id", l.accountId)

        var latestDate sql.NullTime
        if err := db.WithContext(ctx).Model(new(InvestOperation)).
                Select("date").
                Where("invest_account_id = ?", l.accountId).
                Order("date desc").
                Limit(1).
                Scan(&latestDate).
                Error; ctx.Error(&errs, err, "failed to select latest date") {
                return
        }

        from := time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)
        if latestDate.Valid {
                from = latestDate.Time.Add(-l.overlap)
        }

        return nil, jobs.Batch[string]{
                Key:  "cursor",
                Size: l.batchSize,
        }.Run(ctx, investOperationsBatch{
                accountId: l.accountId,
                client:    client,
                db:        db,
                from:      from,
                to:        l.now,
        }.load)
}

type investOperationsBatch struct {
        accountId string
        client    Client
        db        database.DB
        from      time.Time
        to        time.Time
}

func (l investOperationsBatch) load(ctx jobs.Context, cursor string, limit int) (nextCursor *string, errs error) {
        in := &tinkoff.InvestOperationsIn{
                From:               l.from,
                To:                 l.to,
                BrokerAccountId:    l.accountId,
                OvernightsDisabled: pointer.To(false),
                Limit:              limit,
                Cursor:             cursor,
        }

        out, err := l.client.InvestOperations(ctx, in)
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out.Items) == 0 {
                return
        }

        entities, err := database.ToViaJSON[[]InvestOperation](out.Items)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        for i := range entities {
                entities[i].InvestAccountId = l.accountId
        }

        if err := l.db.WithContext(ctx).
                Upsert(entities).
                Error; ctx.Error(&errs, err, "failed to update entities in db") {
                return
        }

        if out.HasNext {
                nextCursor = pointer.To(out.NextCursor)
        }

        ctx.Info("updated entities in db", "count", len(entities))

        return
}

package loaders

import (
        "time"

        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type operations struct {
        accountId string
        batchSize int
        overlap   time.Duration
}

func (l operations) TableName() string {
        return new(Operation).TableName()
}

func (l operations) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        ctx = ctx.With("account_id", l.accountId)

        var since []struct {
                Debited bool
                MinTime time.Time
                MaxTime time.Time
        }

        if err := db.WithContext(ctx).
                Model(new(Operation)).
                Select("debiting_time is not null as debited, min(operation_time) as min_time, max(operation_time) as max_time").
                Where("account_id = ? and status = ?", l.accountId, "OK").
                Group("debited").
                Order("debited").
                Scan(&since).
                Error; ctx.Error(&errs, err, "failed to select latest") {
                return
        }

        start := time.Date(2010, 1, 1, 0, 0, 0, 0, time.UTC)
        for _, row := range since {
                if row.Debited {
                        start = row.MaxTime
                } else {
                        start = row.MinTime
                }

                start = start.Add(-l.overlap)
                break //nolint:all
        }

        ctx = ctx.With("since", start)

        out, err := client.Operations(ctx, &tinkoff.OperationsIn{Account: l.accountId, Start: start})
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out) == 0 {
                return
        }

        entities, err := database.ToViaJSON[[]Operation](out)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        if errs = db.WithContext(ctx).Transaction(func(tx database.DB) (errs error) {
                if err := tx.
                        Where("account_id = ? and status = ? and debiting_time is null and operation_time >= ?", l.accountId, "OK", start).
                        Delete(new(Operation)).
                        Error; ctx.Error(&errs, err, "failed to delete non-debited operations") {
                        return
                }

                if err := tx.UpsertInBatches(entities, l.batchSize).Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                return
        }); errs != nil {
                return
        }

        ctx.Info("updated entities in db", "count", len(entities))
        return
}

package loaders

import (
        "errors"

        "github.com/AlekSi/pointer"
        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type receipts struct {
        phone     string
        batchSize int
}

func (l receipts) TableName() string {
        return new(Receipt).TableName()
}

func (l receipts) Load(ctx jobs.Context, client Client, db database.DB) ([]Interface, error) {
        return nil, jobs.Batch[int]{
                Size: l.batchSize,
                Key:  "offset",
        }.Run(ctx, receiptsBatch{
                phone:  l.phone,
                client: client,
                db:     db,
        }.load)
}

type receiptsBatch struct {
        phone  string
        client Client
        db     database.DB
}

func (l receiptsBatch) load(ctx jobs.Context, offset int, limit int) (nextOffset *int, errs error) {
        var ids []string
        if err := l.db.WithContext(ctx).Model(new(Operation)).
                Select("operations.id").
                Joins("inner join accounts on operations.account_id = accounts.id").
                Joins("left join receipts on operations.id = receipts.operation_id").
                Where("accounts.user_phone = ? "+
                        "and operations.debiting_time is not null "+
                        "and operations.has_shopping_receipt "+
                        "and receipts.operation_id is null", l.phone).
                Order("operations.debiting_time asc").
                Limit(limit).
                Scan(&ids).
                Error; ctx.Error(&errs, err, "failed to select pending") {
                return
        }

        ctx.Debug("selected pending", "count", len(ids))

        for _, id := range ids {
                ctx := ctx.With("operation_id", id)
                out, err := l.client.ShoppingReceipt(ctx, &tinkoff.ShoppingReceiptIn{OperationId: id})
                if err != nil {
                        if errors.Is(err, tinkoff.ErrNoDataFound) {
                                if err := l.db.WithContext(ctx).Model(new(Operation)).
                                        Where("id = ?", id).
                                        Update("has_shopping_receipt", false).
                                        Error; ctx.Error(&errs, err, "failed to mark absent entity in db") {
                                        return
                                }

                                ctx.Info("marked absent entity in db")
                                continue
                        }

                        _ = ctx.Error(&errs, err, "failed to get data from api")
                        return
                }

                entity, err := database.ToViaJSON[Receipt](out.Receipt)
                if ctx.Error(&errs, err, "entity conversion failed") {
                        return
                }

                entity.OperationId = id

                if err := l.db.WithContext(ctx).
                        Upsert(&entity).
                        Error; ctx.Error(&errs, err, "failed to update entities in db") {
                        return
                }

                ctx.Info("updated entity in db")
        }

        if len(ids) == limit {
                nextOffset = pointer.To(offset + limit)
        }

        return
}

package loaders

import (
        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type statements struct {
        accountId string
        batchSize int
}

func (l statements) TableName() string {
        return new(Statement).TableName()
}

func (l statements) Load(ctx jobs.Context, client Client, db database.DB) (ls []Interface, errs error) {
        ctx = ctx.With("account_id", l.accountId)

        out, err := client.Statements(ctx, &tinkoff.StatementsIn{Account: l.accountId})
        if ctx.Error(&errs, err, "failed to get data from api") {
                return
        }

        if len(out) == 0 {
                return
        }

        entities, err := database.ToViaJSON[[]Statement](out)
        if ctx.Error(&errs, err, "entity conversion failed") {
                return
        }

        for i := range entities {
                entities[i].AccountId = l.accountId
        }

        if err := db.WithContext(ctx).
                UpsertInBatches(entities, l.batchSize).
                Error; ctx.Error(&errs, err, "failed to update entities in db") {
                return
        }

        ctx.Info("updated entities in db", "count", len(entities))
        return
}

package firefly

import (
        "context"
        "fmt"

        "github.com/AlekSi/pointer"
        "github.com/pkg/errors"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type accounts struct {
        phone     string
        batchSize int
}

func (s accounts) TableName() string {
        return "accounts"
}

func (s accounts) Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) (ss []Interface, errs error) {
        ctx = ctx.With("phone", s.phone)

        var entities []Account
        if err := db.WithContext(ctx).
                Where("user_phone = ?", s.phone).
                Preload("Currency").
                Find(&entities).
                Error; ctx.Error(&errs, err, "failed to select records") {
                return
        }

        for _, entity := range entities {
                ctx := ctx.With("id", entity.Id)
                if entity.FireflyId != nil {
                        err := updateAccount(ctx, client, entity)
                        if !ctx.Error(&errs, err, "failed to update account") {
                                ss = append(ss, transactions{accountId: entity.Id, batchSize: s.batchSize})
                        }

                        continue
                }

                fireflyId, err := storeAccount(ctx, client, entity)
                if ctx.Error(&errs, err, "failed to store account") {
                        continue
                }

                if err := db.WithContext(ctx).
                        Table(new(Account).TableName()).
                        Where("id = ?", entity.Id).
                        Update("firefly_id", fireflyId).
                        Error; ctx.Error(&errs, err, "failed to update firefly id in db") {
                        continue
                }

                ss = append(ss, transactions{accountId: entity.Id, batchSize: s.batchSize})
        }

        return
}

func updateAccount(ctx context.Context, client firefly.Invoker, account Account) error {
        in := &firefly.AccountUpdate{
                Name:   getAccountName(account),
                Active: firefly.NewOptBool(!account.Deleted),
        }

        out, err := client.UpdateAccount(ctx, in, firefly.UpdateAccountParams{ID: pointer.Get(account.FireflyId)})
        if err != nil {
                return err
        }

        switch out := out.(type) {
        case *firefly.AccountSingle:
                return nil
        case exception:
                return exception2error(out)
        default:
                return errors.Errorf("%s", out)
        }
}

func storeAccount(ctx context.Context, client firefly.Invoker, account Account) (string, error) {
        in := &firefly.AccountStore{
                Name:          getAccountName(account),
                Type:          firefly.ShortAccountTypePropertyAsset,
                AccountNumber: firefly.NewOptNilString(account.Id),
                Active:        firefly.NewOptBool(!account.Deleted),
        }

        if currency := account.Currency; currency != nil {
                if fireflyId := currency.FireflyId; fireflyId != nil {
                        in.CurrencyID = firefly.NewOptString(pointer.Get(currency.FireflyId))
                } else {
                        in.CurrencyCode = firefly.NewOptString(currency.Name)
                }
        }

        switch account.AccountType {
        case "Current":
                in.AccountRole = firefly.NewOptNilAccountRoleProperty(firefly.AccountRolePropertyDefaultAsset)
        case "Saving":
                in.AccountRole = firefly.NewOptNilAccountRoleProperty(firefly.AccountRolePropertySavingAsset)
        case "Credit":
                in.AccountRole = firefly.NewOptNilAccountRoleProperty(firefly.AccountRolePropertyCcAsset)
                in.CreditCardType = firefly.NewOptNilCreditCardType(firefly.CreditCardTypeMonthlyFull)
                if dueDate := account.DueDate; dueDate != nil {
                        in.MonthlyPaymentDate = firefly.NewOptNilDateTime(dueDate.Time())
                }
        }

        out, err := client.StoreAccount(ctx, in, firefly.StoreAccountParams{})
        if err != nil {
                return "", err
        }

        switch out := out.(type) {
        case *firefly.AccountSingle:
                return out.Data.ID, nil
        case exception:
                return "", exception2error(out)
        default:
                return "", errors.Errorf("%s", out)
        }
}

func getAccountName(account Account) string {
        return fmt.Sprintf("%s (%s)", account.Name, account.Id)
}

package firefly

import (
        "context"

        "github.com/pkg/errors"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type Categories struct{}

func (s Categories) TableName() string {
        return "categories"
}

func (s Categories) Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) (ss []Interface, errs error) {
        var entities []SpendingCategory
        if err := db.WithContext(ctx).
                Where("firefly_id is null").
                Find(&entities).
                Error; ctx.Error(&errs, err, "failed to select pending records") {
                return
        }

        for _, entity := range entities {
                ctx := ctx.With("name", entity.Name)
                fireflyId, err := storeCategory(ctx, client, entity)
                if ctx.Error(&errs, err, "failed to store category") {
                        continue
                }

                if err := db.WithContext(ctx).
                        Table(new(SpendingCategory).TableName()).
                        Where("id = ?", entity.Id).
                        Update("firefly_id", fireflyId).
                        Error; ctx.Error(&errs, err, "failed to update firefly id in db") {
                        continue
                }
        }

        return
}

func storeCategory(ctx context.Context, client firefly.Invoker, category SpendingCategory) (string, error) {
        in := &firefly.Category{
                Name: category.Name,
        }

        out, err := client.StoreCategory(ctx, in, firefly.StoreCategoryParams{})
        if err != nil {
                return "", err
        }

        switch out := out.(type) {
        case *firefly.CategorySingle:
                return out.Data.ID, nil
        case exception:
                return "", exception2error(out)
        default:
                return "", errors.Errorf("%s", out)
        }
}

package firefly

import (
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
)

type All struct {
        Phones    []string
        BatchSize int
}

func (s All) TableName() string {
        return "base"
}

func (s All) Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) (ls []Interface, errs error) {
        for _, sync := range []Interface{
                Categories{},
                Currencies{},
        } {
                ctx := ctx.With("subentity", sync.TableName())
                _, err := sync.Sync(ctx, db, client)
                _ = multierr.AppendInto(&errs, err)
        }

        if errs != nil {
                return
        }

        for _, phone := range s.Phones {
                ls = append(ls, accounts{
                        phone:     phone,
                        batchSize: s.BatchSize,
                })
        }

        return
}

package firefly

import (
        "context"

        "github.com/pkg/errors"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type Currencies struct{}

func (s Currencies) TableName() string {
        return "currencies"
}

func (s Currencies) Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) (ss []Interface, errs error) {
        var entities []Currency
        if err := db.WithContext(ctx).
                Where("firefly_id is null").
                Find(&entities).
                Error; ctx.Error(&errs, err, "failed to select pending records") {
                return
        }

        for _, entity := range entities {
                ctx := ctx.With("name", entity.Name)
                fireflyId, err := storeCurrency(ctx, client, entity)
                if ctx.Error(&errs, err, "failed to store currency") {
                        continue
                }

                if err := db.WithContext(ctx).
                        Table(new(Currency).TableName()).
                        Where("code = ?", entity.Code).
                        Update("firefly_id", fireflyId).
                        Error; ctx.Error(&errs, err, "failed to update firefly id in db") {
                        continue
                }
        }

        return
}

func storeCurrency(ctx context.Context, client firefly.Invoker, currency Currency) (string, error) {
        code := currency.Name
        existing, err := getCurrency(ctx, client, code)
        if err != nil {
                return "", errors.Wrap(err, "get currency")
        }

        if existing != nil {
                if !existing.Data.Attributes.Enabled.Value {
                        if err := enableCurrency(ctx, client, code); err != nil {
                                return "", errors.Wrap(err, "enable currency")
                        }
                }

                return existing.Data.ID, nil
        }

        in := &firefly.CurrencyStore{
                Enabled:       firefly.NewOptBool(true),
                Code:          code,
                Name:          code,
                Symbol:        code,
                DecimalPlaces: firefly.NewOptInt32(2),
        }

        out, err := client.StoreCurrency(ctx, in, firefly.StoreCurrencyParams{})
        if err != nil {
                return "", err
        }

        switch out := out.(type) {
        case *firefly.CurrencySingle:
                return out.Data.ID, nil
        case exception:
                return "", exception2error(out)
        default:
                return "", errors.Errorf("%s", out)
        }
}

func enableCurrency(ctx context.Context, client firefly.Invoker, code string) error {
        in := &firefly.CurrencyUpdate{
                Enabled: firefly.NewOptBool(true),
        }

        out, err := client.UpdateCurrency(ctx, in, firefly.UpdateCurrencyParams{Code: code})
        if err != nil {
                return err
        }

        switch out := out.(type) {
        case *firefly.CurrencySingle:
                return nil
        case exception:
                return exception2error(out)
        default:
                return errors.Errorf("%s", out)
        }
}

func getCurrency(ctx context.Context, client firefly.Invoker, code string) (*firefly.CurrencySingle, error) {
        out, err := client.GetCurrency(ctx, firefly.GetCurrencyParams{Code: code})
        if err != nil {
                return nil, err
        }

        switch out := out.(type) {
        case *firefly.CurrencySingle:
                return out, nil
        case *firefly.NotFound:
                return nil, nil
        case exception:
                return nil, exception2error(out)
        default:
                return nil, errors.Errorf("%s", out)
        }
}

package firefly

import (
        "errors"
        "fmt"

        "gorm.io/gorm/schema"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
)

type exception interface {
        GetMessage() firefly.OptString
        GetException() firefly.OptString
}

func exception2error(e exception) error {
        return errors.New(e.GetMessage().
                Or(e.GetException().
                        Or(fmt.Sprintf("%T", e))))
}

type Interface interface {
        schema.Tabler
        Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) ([]Interface, error)
}

package firefly

import (
        "context"
        "time"

        "github.com/AlekSi/pointer"
        "github.com/pkg/errors"

        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type transactionQueryRow struct {
        OperationId                     string
        OperationTime                   time.Time
        DebitingTime                    time.Time
        Description                     string
        FireflyCategoryId               string
        FireflyCurrencyId               string
        Amount                          string
        FireflyForeignCurrencyId        string
        ForeignAmount                   string
        SourceOperationId               *string
        FireflySourceTransactionId      *string
        FireflySourceAccountId          *string
        DestinationOperationId          *string
        FireflyDestinationTransactionId *string
        FireflyDestinationAccountId     *string
}

type transactions struct {
        accountId string
        batchSize int
}

func (s transactions) TableName() string {
        return "transactions"
}

func (s transactions) Sync(ctx jobs.Context, db database.DB, client firefly.Invoker) ([]Interface, error) {
        ctx = ctx.With("account_id", s.accountId)
        return nil, jobs.Batch[int]{
                Key:  "offset",
                Size: s.batchSize,
        }.Run(ctx, transactionsBatch{
                db:        db,
                client:    client,
                accountId: s.accountId,
        }.sync)
}

type transactionsBatch struct {
        db        database.DB
        client    firefly.Invoker
        accountId string
}

func (s transactionsBatch) sync(ctx jobs.Context, offset int, limit int) (nextOffset *int, errs error) {
        var rows []transactionQueryRow
        if err := s.db.WithContext(ctx).
                Raw(transactionQuerySQL, s.accountId, limit).
                Scan(&rows).
                Error; ctx.Error(&errs, err, "failed to query operations") {
                return
        }

        for _, row := range rows {
                ctx := ctx.With("operation_id", row.OperationId)
                if row.SourceOperationId != nil && row.DestinationOperationId != nil &&
                        ((row.FireflySourceTransactionId == nil) != (row.FireflyDestinationTransactionId == nil)) {
                        var (
                                transactionId *string
                                operationId   *string
                        )

                        if row.FireflySourceTransactionId != nil {
                                transactionId = row.FireflySourceTransactionId
                                operationId = row.SourceOperationId
                        } else {
                                transactionId = row.FireflyDestinationTransactionId
                                operationId = row.DestinationOperationId
                        }

                        if err := deleteTransaction(ctx, s.client, *transactionId); ctx.Error(&errs, err, "failed to delete transaction") {
                                continue
                        }

                        if err := s.db.WithContext(ctx).
                                Table(new(Operation).TableName()).
                                Where("id = ?", *operationId).
                                Update("firefly_id", nil).
                                Error; ctx.Error(&errs, err, "failed to delete firefly id from db") {
                                continue
                        }

                        row.FireflySourceTransactionId = nil
                        row.FireflyDestinationTransactionId = nil
                }

                if row.FireflySourceTransactionId != nil || row.FireflyDestinationTransactionId != nil {
                        continue
                }

                fireflyId, err := storeTransaction(ctx, s.client, &row)
                if ctx.Error(&errs, err, "failed to store transaction") {
                        continue
                }

                if err := s.db.WithContext(ctx).
                        Table(new(Operation).TableName()).
                        Where("id in ?", []any{row.SourceOperationId, row.DestinationOperationId}).
                        Update("firefly_id", fireflyId).
                        Error; ctx.Error(&errs, err, "failed to update firefly id in db") {
                        continue
                }
        }

        if len(rows) == limit {
                nextOffset = pointer.To(offset + limit)
        }

        return
}

type transaction interface {
        SetProcessDate(firefly.OptNilDateTime)
        SetCategoryID(firefly.OptNilString)
        SetCurrencyID(firefly.OptNilString)
        SetForeignCurrencyID(firefly.OptNilString)
        SetForeignAmount(firefly.OptNilString)
        SetSourceID(firefly.OptNilString)
        SetDestinationID(firefly.OptNilString)
}

func deleteTransaction(ctx context.Context, client firefly.Invoker, transactionId string) error {
        out, err := client.DeleteTransaction(ctx, firefly.DeleteTransactionParams{ID: transactionId})
        if err != nil {
                return err
        }

        switch out := out.(type) {
        case *firefly.DeleteTransactionNoContent, *firefly.NotFound:
                return nil
        case exception:
                return exception2error(out)
        default:
                return errors.Errorf("%s", out)
        }
}

func storeTransaction(ctx context.Context, client firefly.Invoker, row *transactionQueryRow) (string, error) {
        var transaction firefly.TransactionSplitStore
        transactionType := setTransactionFields(row, &transaction)
        transaction.SetType(transactionType)
        transaction.SetDate(row.OperationTime)
        transaction.SetDescription(row.Description)
        transaction.SetAmount(row.Amount)

        in := &firefly.TransactionStore{
                Transactions: []firefly.TransactionSplitStore{
                        transaction,
                },
        }

        out, err := client.StoreTransaction(ctx, in, firefly.StoreTransactionParams{})
        if err != nil {
                return "", err
        }

        switch out := out.(type) {
        case *firefly.TransactionSingle:
                return out.Data.ID, nil
        case exception:
                return "", exception2error(out)
        default:
                return "", errors.Errorf("%s", out)
        }
}

func setTransactionFields(row *transactionQueryRow, transaction transaction) firefly.TransactionTypeProperty {
        transaction.SetProcessDate(firefly.NewOptNilDateTime(row.OperationTime))
        transaction.SetCategoryID(firefly.NewOptNilString(row.FireflyCategoryId))

        var transactionType firefly.TransactionTypeProperty
        if row.FireflySourceAccountId != nil {
                transactionType = firefly.TransactionTypePropertyWithdrawal
                transaction.SetSourceID(firefly.NewOptNilString(*row.FireflySourceAccountId))
        } else {
                transactionType = firefly.TransactionTypePropertyDeposit
                row.FireflyCurrencyId, row.FireflyForeignCurrencyId = row.FireflyForeignCurrencyId, row.FireflyCurrencyId
                row.Amount, row.ForeignAmount = row.ForeignAmount, row.Amount
        }

        if row.FireflyDestinationAccountId != nil {
                if transactionType == firefly.TransactionTypePropertyWithdrawal {
                        transactionType = firefly.TransactionTypePropertyTransfer
                }

                transaction.SetDestinationID(firefly.NewOptNilString(*row.FireflyDestinationAccountId))
        }

        transaction.SetCurrencyID(firefly.NewOptNilString(row.FireflyCurrencyId))
        if row.FireflyCurrencyId != row.FireflyForeignCurrencyId || transactionType == firefly.TransactionTypePropertyTransfer {
                transaction.SetForeignCurrencyID(firefly.NewOptNilString(row.FireflyForeignCurrencyId))
                transaction.SetForeignAmount(firefly.NewOptNilString(row.ForeignAmount))
        }

        return transactionType
}

const transactionQuerySQL = `
with o as (select *, row_number() over (order by operation_time, id::bigint) as num
           from operations
           where status = 'OK'
             and debiting_time is not null)
select coalesce(lo.id, ro.id)                             as operation_id,
       coalesce(lo.firefly_id, ro.firefly_id)             as firefly_id,
       coalesce(lo.operation_time, ro.operation_time)     as operation_time,
       coalesce(lo.debiting_time, ro.debiting_time)       as debiting_time,
       coalesce(lo.description, ro.description)           as description,
       sc.firefly_id                                      as firefly_category_id,
       lc.firefly_id                                      as firefly_currency_id,
       coalesce(lo.account_value, ro.value)::text         as amount,
       rc.firefly_id                                      as firefly_foreign_currency_id,
       coalesce(ro.account_value, lo.value)::text         as foreign_amount,
       case when la.firefly_id is not null then lo.id end as source_operation_id,
       lo.firefly_id                                      as firefly_source_transaction_id,
       la.firefly_id                                      as firefly_source_account_id,
       case when ra.firefly_id is not null then ro.id end as destination_operation_id,
       ro.firefly_id                                      as firefly_destination_transaction_id,
       ra.firefly_id                                      as firefly_destination_account_id
from o as lo
         full join o as ro on ro.sender_agreement = lo.account_id and
                              (lo.num + 1 = ro.num or lo.operation_time = ro.operation_time) and
                              (lo.value = ro.account_value or lo.account_value = ro.value) and
                              (lo."group" = 'TRANSFER' and ro."group" = 'INCOME')
         inner join spending_categories sc on coalesce(lo.spending_category_id, ro.spending_category_id) = sc.id
         inner join currencies lc on coalesce(lo.account_currency_code, ro.currency_code) = lc.code
         inner join currencies rc on coalesce(ro.account_currency_code, lo.currency_code) = rc.code
         left join accounts la on lo.account_id = la.id
         left join accounts ra on ro.account_id = ra.id
where coalesce(lo.type, 'Debit') = 'Debit'
  and coalesce(ro.type, 'Credit') = 'Credit'
  and ? in (lo.account_id, ro.account_id)
  and (la.firefly_id is not null and lo.firefly_id is null or ra.firefly_id is not null and ro.firefly_id is null)
order by 1::bigint
limit ?
`

package tinkoff

import (
        "context"
        "log/slog"
        "time"

        "github.com/jfk9w-go/based"
        "github.com/jfk9w-go/tinkoff-api/v2"
        "github.com/pkg/errors"
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/common"
        "github.com/jfk9w/hoarder/internal/database"
        "github.com/jfk9w/hoarder/internal/firefly"
        "github.com/jfk9w/hoarder/internal/jobs"
        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
        "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/loaders"
        fireflySync "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/sync/firefly"
        "github.com/jfk9w/hoarder/internal/logs"
        "github.com/jfk9w/hoarder/internal/selenium"
)

const JobID = "tinkoff"

type JobParams struct {
        Clock         based.Clock  `validate:"required"`
        Logger        *slog.Logger `validate:"required"`
        Config        Config       `validate:"required"`
        ClientFactory ClientFactory
        Firefly       firefly.Invoker
        Selenium      *selenium.Service
}

type Job struct {
        users        map[string]map[string]pingingClient
        batchSize    int
        overlap      time.Duration
        withReceipts bool
        db           database.DB
        firefly      firefly.Invoker
}

func NewJob(ctx context.Context, params JobParams) (*Job, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        authFlow := tinkoff.ApiAuthFlow
        if service := params.Selenium; service != nil {
                authFlow = &tinkoff.SeleniumAuthFlow{
                        Capabilities: service.Capabilities(),
                        URLPrefix:    service.URLPrefix(),
                }
        }

        if params.ClientFactory == nil {
                params.ClientFactory = defaultClientFactory
        }

        db, err := database.Open(ctx, database.Params{
                Clock:    params.Clock,
                Logger:   params.Logger.With(logs.Database(JobID)),
                Config:   params.Config.Database,
                Entities: entities,
        })

        if err != nil {
                return nil, err
        }

        storage := &storage{db: db}
        users := make(map[string]map[string]pingingClient)
        for user, credentials := range params.Config.Users {
                phones := make(map[string]pingingClient)
                users[user] = phones
                for _, credential := range credentials {
                        client, err := params.ClientFactory(tinkoff.ClientParams{
                                Clock: params.Clock,
                                Credential: tinkoff.Credential{
                                        Phone:    credential.Phone,
                                        Password: credential.Password,
                                },
                                SessionStorage: storage,
                                AuthFlow:       authFlow,
                        })

                        if err != nil {
                                return nil, errors.Wrapf(err, "create client for %s/%s", user, credential.Phone)
                        }

                        phones[credential.Phone] = pingingClient{
                                Client: client,
                                pinger: based.Go(context.Background(), client.Ping),
                        }
                }
        }

        return &Job{
                users:        users,
                batchSize:    params.Config.BatchSize,
                overlap:      params.Config.Overlap,
                withReceipts: params.Config.WithReceipts,
                db:           db,
                firefly:      params.Firefly,
        }, nil
}

func (j *Job) Close() (errs error) {
        for _, phones := range j.users {
                for phone, client := range phones {
                        _ = multierr.AppendInto(&errs, errors.Wrap(client.Close(), phone))
                }
        }

        return
}

func (j *Job) Info() jobs.Info {
        return jobs.Info{
                ID:          JobID,
                Description: "Загрузка счетов, операций и пр. из Т-Банка и Т-Инвестиций",
        }
}

func (j *Job) Run(ctx jobs.Context, now time.Time, userID string) (errs error) {
        phones := j.users[userID]
        if phones == nil {
                return jobs.ErrJobUnconfigured
        }

        ctx = ctx.ApplyAskFn(withAuthorizer)
        for phone, client := range phones {
                ctx := ctx.With("phone", phone)
                err := j.executeLoaders(ctx, now, userID, phone, client)
                _ = multierr.AppendInto(&errs, err)
        }

        if err := j.executeFireflySync(ctx, userID); err != nil {
                _ = multierr.AppendInto(&errs, err)
        }

        return
}

func (j *Job) executeLoaders(ctx jobs.Context, now time.Time, userID string, phone string, client Client) (errs error) {
        if err := j.db.WithContext(ctx).
                Upsert(&User{Name: userID, Phone: phone}).
                Error; ctx.Error(&errs, err, "failed to create user in db") {
                return
        }

        var stack common.Stack[loaders.Interface]
        stack.Push(
                loaders.ClientOffers{Phone: phone, BatchSize: j.batchSize},
                loaders.Accounts{Phone: phone, BatchSize: j.batchSize, Overlap: j.overlap, WithReceipts: j.withReceipts},
                loaders.InvestOperationTypes{BatchSize: j.batchSize},
                loaders.InvestAccounts{Phone: phone, BatchSize: j.batchSize, Overlap: j.overlap, Now: now},
        )

        for {
                loader, ok := stack.Pop()
                if !ok {
                        break
                }

                ctx := ctx.With("entity", loader.TableName())
                loaders, err := loader.Load(ctx, client, j.db)
                if !multierr.AppendInto(&errs, err) {
                        stack.Push(loaders...)
                }
        }

        return
}

func (j *Job) executeFireflySync(ctx jobs.Context, userID string) (errs error) {
        if j.firefly == nil {
                return
        }

        var phones []string
        for phone := range j.users[userID] {
                phones = append(phones, phone)
        }

        var stack common.Stack[fireflySync.Interface]
        stack.Push(fireflySync.All{Phones: phones, BatchSize: j.batchSize})

        for {
                sync, ok := stack.Pop()
                if !ok {
                        break
                }

                ctx := ctx.With("entity", sync.TableName())
                syncs, err := sync.Sync(ctx, j.db, j.firefly)
                if !multierr.AppendInto(&errs, err) {
                        stack.Push(syncs...)
                }
        }

        return
}

package tinkoff

import (
        "context"

        "github.com/jfk9w/hoarder/internal/database"

        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/pkg/errors"
        "gorm.io/gorm"

        . "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/entities"
)

type storage struct {
        db database.DB
}

func (s *storage) LoadSession(ctx context.Context, phone string) (*tinkoff.Session, error) {
        var entity Session
        if err := s.db.First(&entity, phone).Error; err != nil {
                if errors.Is(err, gorm.ErrRecordNotFound) {
                        return nil, nil
                }

                return nil, errors.Wrap(err, "get session from db")
        }

        return database.ToViaJSON[*tinkoff.Session](entity)
}

func (s *storage) UpdateSession(ctx context.Context, phone string, session *tinkoff.Session) error {
        if session == nil {
                return errors.Wrap(s.db.Delete(new(Session), phone).Error, "delete session from db")
        }

        entity, err := database.ToViaJSON[*Session](session)
        if err != nil {
                return err
        }

        entity.UserPhone = phone

        if err := s.db.Upsert(entity).Error; err != nil {
                return errors.Wrap(err, "save session in db")
        }

        return nil
}

package tinkoff

import (
        "github.com/jfk9w-go/tinkoff-api/v2"

        "github.com/jfk9w/hoarder/internal/jobs/tinkoff/internal/loaders"
)

type Client = loaders.Client

type ClientFactory func(params tinkoff.ClientParams) (Client, error)

var defaultClientFactory ClientFactory = func(params tinkoff.ClientParams) (Client, error) {
        return tinkoff.NewClient(params)
}

package logs

import (
        "log/slog"
        "os"
)

type Encoding string

const (
        Text Encoding = "text"
        JSON Encoding = "json"
)

func (Encoding) SchemaEnum() any {
        return []Encoding{
                Text,
                JSON,
        }
}

type Config struct {
        Level     slog.Level `yaml:"level,omitempty" default:"INFO" doc:"Уровень логирования." enum:"DEBUG,INFO,WARN,ERROR"`
        Encoding  Encoding   `yaml:"encoding,omitempty" default:"text" doc:"Формат логирования."`
        AddSource bool       `yaml:"addSource,omitempty" doc:"Добавлять ли номера строк в логи."`
}

func Get(cfg Config) *slog.Logger {
        opts := &slog.HandlerOptions{
                AddSource: cfg.AddSource,
                Level:     cfg.Level,
        }

        var handler slog.Handler
        switch cfg.Encoding {
        case JSON:
                handler = slog.NewJSONHandler(os.Stderr, opts)
        default:
                handler = slog.NewTextHandler(os.Stderr, opts)
        }

        return slog.New(handler)
}

package logs

import "log/slog"

func Trigger(id string) slog.Attr {
        return slog.String("trigger", id)
}

func User(id string) slog.Attr {
        return slog.String("user", id)
}

func Error(err error) slog.Attr {
        return slog.String("error", err.Error())
}

func Database(name string) slog.Attr {
        return slog.String("database", name)
}

package selenium

import "os/exec"

type Config struct {
        Jar     string   `yaml:"jar" doc:"Путь к JAR-файлу selenium-server-standalone."`
        Driver  string   `yaml:"driver,omitempty" doc:"Путь к драйверу. Если пустой, будет выполнен поиск в $PATH."`
        Browser string   `yaml:"browser,omitempty" enum:"chrome,chromium,firefox" default:"firefox" doc:"Браузер (browserName в Selenium)."`
        Binary  string   `yaml:"binary,omitempty" doc:"Путь к исполняемому файлу браузера."`
        Args    []string `yaml:"args,omitempty" doc:"Аргументы для запуска браузера." default:"[--headless]"`
}

func (cfg Config) getDriverPath(defaultPath string) (string, error) {
        driverPath := cfg.Driver
        if driverPath == "" {
                driverPath = defaultPath
        }

        return exec.LookPath(driverPath)
}

package selenium

import (
        "fmt"
        "net"

        "github.com/go-faster/errors"
        "github.com/jfk9w-go/based"
        "github.com/tebeka/selenium"
        "github.com/tebeka/selenium/chrome"
        "github.com/tebeka/selenium/firefox"
)

type ServiceParams struct {
        Config Config `validate:"required"`
}

type Service struct {
        service   *selenium.Service
        caps      selenium.Capabilities
        urlPrefix string
}

func NewService(params ServiceParams) (*Service, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        opts := []selenium.ServiceOption{
                // selenium.StartFrameBuffer(),
        }

        caps := selenium.Capabilities{}
        switch params.Config.Browser {
        case "firefox":
                driverPath, err := params.Config.getDriverPath("geckodriver")
                if err != nil {
                        return nil, errors.Wrap(err, "find geckodriver")
                }

                opts = append(opts, selenium.GeckoDriver(driverPath))
                caps.AddFirefox(firefox.Capabilities{
                        Args:   params.Config.Args,
                        Binary: params.Config.Binary,
                })

        case "chrome", "chromium":
                driverPath, err := params.Config.getDriverPath("chromedriver")
                if err != nil {
                        return nil, errors.Wrap(err, "find chromedriver")
                }

                opts = append(opts, selenium.ChromeDriver(driverPath))
                caps.AddChrome(chrome.Capabilities{
                        Args: params.Config.Args,
                        Path: params.Config.Binary,
                })

        default:
                return nil, errors.New("unsupported browser")
        }

        port, err := getFreePort()
        if err != nil {
                return nil, errors.Wrap(err, "find free port")
        }

        service, err := selenium.NewSeleniumService(params.Config.Jar, port, opts...)
        if err != nil {
                return nil, errors.Wrap(err, "init selenium service")
        }

        return &Service{
                service:   service,
                caps:      caps,
                urlPrefix: fmt.Sprintf("http://localhost:%d/wd/hub", port),
        }, nil
}

func (f *Service) Capabilities() selenium.Capabilities {
        return f.caps
}

func (f *Service) URLPrefix() string {
        return f.urlPrefix
}

func (f *Service) Stop() {
        _ = f.service.Stop()
}

func getFreePort() (port int, err error) {
        var a *net.TCPAddr
        if a, err = net.ResolveTCPAddr("tcp", "localhost:0"); err == nil {
                var l *net.TCPListener
                if l, err = net.ListenTCP("tcp", a); err == nil {
                        defer l.Close()
                        return l.Addr().(*net.TCPAddr).Port, nil
                }
        }

        return
}

package triggers

import (
        "context"
        "log/slog"
        "time"

        "github.com/jfk9w/hoarder/internal/jobs"
)

type loggerKey struct{}

type Context struct {
        std context.Context
        log *slog.Logger
}

func NewContext(ctx context.Context, log *slog.Logger) Context {
        return Context{
                std: context.WithValue(ctx, loggerKey{}, log),
                log: log,
        }
}

func ContextFrom(ctx context.Context) Context {
        return Context{
                std: ctx,
                log: ctx.Value(loggerKey{}).(*slog.Logger),
        }
}

func (ctx Context) Deadline() (time.Time, bool) { return ctx.std.Deadline() }
func (ctx Context) Done() <-chan struct{}       { return ctx.std.Done() }
func (ctx Context) Err() error                  { return ctx.std.Err() }
func (ctx Context) Value(key any) any           { return ctx.std.Value(key) }

func (ctx Context) Debug(msg string, args ...any) { ctx.log.Debug(msg, args...) }
func (ctx Context) Info(msg string, args ...any)  { ctx.log.Info(msg, args...) }
func (ctx Context) Warn(msg string, args ...any)  { ctx.log.Warn(msg, args...) }
func (ctx Context) Error(msg string, args ...any) { ctx.log.Error(msg, args...) }

func (ctx Context) With(key string, value any) Context {
        ctx.log = ctx.log.With(slog.Any(key, value))
        ctx.std = context.WithValue(ctx.std, loggerKey{}, ctx.log)
        return ctx
}

func (ctx Context) As(userID string) Context {
        return ctx.With("user", userID)
}

func (ctx Context) Job() jobs.Context {
        return jobs.NewContext(ctx.std, ctx.log)
}

package schedule

import (
        "sync"
        "time"

        "github.com/jfk9w-go/based"

        "github.com/jfk9w/hoarder/internal/triggers"
)

const TriggerID = "schedule"

type Config struct {
        Users    map[string][]string `yaml:"users" doc:"ID пользователей, для которых данные нужно синхронизировать в фоновом режиме."`
        Interval time.Duration       `yaml:"interval,omitempty" default:"30m" doc:"Интервал синхронизации."`
}

type TriggerParams struct {
        Clock  based.Clock `validate:"required"`
        Config Config      `validate:"required"`
}

type Trigger struct {
        clock    based.Clock
        users    map[string][]string
        interval time.Duration
}

func NewTrigger(params TriggerParams) (*Trigger, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        return &Trigger{
                clock:    params.Clock,
                users:    params.Config.Users,
                interval: params.Config.Interval,
        }, nil
}

func (t *Trigger) ID() string {
        return TriggerID
}

func (t *Trigger) Run(ctx triggers.Context, job triggers.Jobs) {
        for {
                now := t.clock.Now()
                timeout := now.Round(t.interval).Sub(now)
                if timeout < 0 {
                        timeout += t.interval
                }

                select {
                case <-ctx.Done():
                        return
                case <-time.After(timeout):
                }

                var wg sync.WaitGroup
                for userID, jobIDs := range t.users {
                        ctx := ctx.As(userID)
                        wg.Add(1)
                        go func(userID string, jobIDs []string) {
                                defer wg.Done()
                                _ = job.Run(ctx.Job(), now, userID, jobIDs)
                        }(userID, jobIDs)
                }

                wg.Wait()
        }
}

package stdin

import (
        "bufio"
        "context"
        "errors"
        "fmt"
        "io"
        "os"
        "strings"

        "github.com/jfk9w-go/based"
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/logs"
        "github.com/jfk9w/hoarder/internal/triggers"
)

const TriggerID = "stdin"

type TriggerParams struct {
        Clock  based.Clock `validate:"required"`
        Reader io.Reader
        Writer io.Writer
}

type Trigger struct {
        clock based.Clock
        in    io.Reader
        out   io.Writer
}

func NewTrigger(params TriggerParams) (*Trigger, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        if params.Reader == nil {
                params.Reader = os.Stdin
        }

        if params.Writer == nil {
                params.Writer = os.Stdout
        }

        return &Trigger{
                clock: params.Clock,
                in:    params.Reader,
                out:   params.Writer,
        }, nil
}

func (t *Trigger) ID() string {
        return TriggerID
}

func (t *Trigger) Run(ctx triggers.Context, job triggers.Jobs) {
        for {
                userID, err := t.ask(ctx, "Enter user: ")
                if err != nil {
                        ctx.Error("failed to get user", logs.Error(err))
                        return
                }

                ctx := ctx.As(userID)
                jobIDs, err := t.ask(ctx, "Enter jobs: ")
                if err != nil {
                        ctx.Error("failed to get jobs", logs.Error(err))
                        return
                }

                results := job.Run(ctx.Job().WithAskFn(t.ask), t.clock.Now(), userID, strings.Fields(jobIDs))
                var reply strings.Builder
                for _, result := range results {
                        if result.Error == nil {
                                reply.WriteString(" ✔ ")
                                reply.WriteString(result.JobID)
                                reply.WriteRune('\n')
                        } else {
                                for _, err := range multierr.Errors(result.Error) {
                                        reply.WriteString(" ✘ ")
                                        reply.WriteString(result.JobID)
                                        reply.WriteString(": ")
                                        reply.WriteString(err.Error())
                                        reply.WriteRune('\n')
                                }
                        }
                }

                if _, err := fmt.Fprintln(t.out, reply.String()); err != nil {
                        ctx.Error("failed to print result", logs.Error(err))
                        return
                }
        }
}

func (t *Trigger) ask(_ context.Context, prompt string) (string, error) {
        if _, err := fmt.Fprint(t.out, prompt); err != nil {
                return "", err
        }

        scanner := bufio.NewScanner(t.in)
        if ok := scanner.Scan(); !ok {
                return "", errors.New("scan failed")
        }

        return scanner.Text(), nil
}

package telegram

import (
        "context"
        "fmt"
        "log/slog"
        "time"

        "github.com/jfk9w-go/based"
        "github.com/mr-linch/go-tg"
        "github.com/mr-linch/go-tg/tgb"
        "github.com/pkg/errors"
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/common"
        "github.com/jfk9w/hoarder/internal/logs"
        "github.com/jfk9w/hoarder/internal/triggers"
)

const (
        TriggerID = "telegram"

        startCommand = "start"
)

type Config struct {
        Token  string                            `yaml:"token" doc:"Токен бота."`
        Users  common.UserMap[string, tg.UserID] `yaml:"users" doc:"Маппинг пользователей в ID в Telegram."`
        Typing time.Duration                     `yaml:"typing,omitempty" doc:"Интервал для отправки действия \"печатает...\"." default:"4s"`
}

type TriggerParams struct {
        Clock  based.Clock  `validate:"required"`
        Config Config       `validate:"required"`
        Logger *slog.Logger `validate:"required"`
}

type Trigger struct {
        clock     based.Clock
        config    Config
        log       *slog.Logger
        users     map[tg.UserID]string
        questions common.Questions[string, string]
}

func NewTrigger(params TriggerParams) (*Trigger, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        users, err := params.Config.Users.Reverse()
        if err != nil {
                return nil, errors.Wrap(err, "parse users")
        }

        return &Trigger{
                clock:     params.Clock,
                config:    params.Config,
                log:       params.Logger,
                users:     users,
                questions: common.NewQuestions[string, string](),
        }, nil
}

func (t *Trigger) ID() string {
        return TriggerID
}

func (t *Trigger) Run(ctx triggers.Context, jobs triggers.Jobs) {
        client := tg.New(t.config.Token)
        commands := []tg.BotCommand{
                {
                        Command:     startCommand,
                        Description: "Получение информации о чате и пользователе",
                },
        }

        if err := client.SetMyCommands(commands).DoVoid(ctx); err != nil {
                t.log.Error("failed to set my commands", logs.Error(err), slog.String("scope", "default"))
                return
        }

        for _, info := range jobs.Info() {
                commands = append(commands, tg.BotCommand{
                        Command:     info.ID,
                        Description: info.Description,
                })
        }

        for userID := range t.users {
                if err := client.SetMyCommands(commands).
                        Scope(tg.BotCommandScopeChat{ChatID: tg.ChatID(userID)}).
                        DoVoid(ctx); err != nil {
                        t.log.Error("failed to set my commands", slog.String("scope", "chat"), slog.Any("user", userID), logs.Error(err))
                        return
                }
        }

        router := tgb.NewRouter().
                Message(t.answer, t, tgb.Not(tgb.MessageEntity(tg.MessageEntityTypeBotCommand))).
                Message(t.start, tgb.Command(startCommand))

        for _, info := range jobs.Info() {
                jobID := info.ID
                router.Message(func(ctx context.Context, msg *tgb.MessageUpdate) error {
                        return t.execute(ctx, msg, client, jobs, jobID)
                }, t, tgb.Command(jobID))
        }

        if err := tgb.NewPoller(withBoundContext(router), client,
                tgb.WithPollerAllowedUpdates(tg.UpdateTypeMessage)).
                Run(ctx); err != nil {
                t.log.Error("failed to start poller", logs.Error(err))
        }
}

func (t *Trigger) execute(ctx context.Context, msg *tgb.MessageUpdate, client *tg.Client, jobs triggers.Jobs, jobID string) error {
        userID, _ := t.getUserID(msg.From)
        typing := t.typing(ctx, client, msg.Chat.ID)
        jctx := triggers.ContextFrom(ctx).As(userID).Job().
                WithAskFn(func(ctx context.Context, text string) (string, error) {
                        typing.Cancel()
                        _ = typing.Join(ctx)
                        return t.questions.Ask(ctx, userID, func(ctx context.Context, userID string) error {
                                if err := msg.Answer(tg.HTML.Text(text)).DoVoid(ctx); err != nil {
                                        return err
                                }

                                typing = t.typing(ctx, client, msg.Chat.ID)
                                return nil
                        })
                })

        report := make([]string, 0)
        for _, result := range jobs.Run(jctx, t.clock.Now(), userID, []string{jobID}) {
                if err := result.Error; err != nil {
                        for _, err := range multierr.Errors(err) {
                                report = append(report, fmt.Sprintf("✘ %s: %s", result.JobID, err.Error()))
                        }
                } else {
                        report = append(report, fmt.Sprintf("✔ %s", result.JobID))
                }
        }

        return msg.Answer(tg.HTML.Text(report...)).DoVoid(ctx)
}

func (t *Trigger) start(ctx context.Context, msg *tgb.MessageUpdate) error {
        return msg.Answer(tg.HTML.Text(
                fmt.Sprintf("User ID: %d", msg.From.ID),
                fmt.Sprintf("Chat ID: %d", msg.Chat.ID),
        )).DoVoid(ctx)
}

func (t *Trigger) answer(ctx context.Context, msg *tgb.MessageUpdate) error {
        userID, _ := t.getUserID(msg.From)
        err := t.questions.Answer(ctx, userID, msg.Text)
        if err == common.ErrNoQuestions {
                return nil
        }

        return err
}

func (t *Trigger) typing(ctx context.Context, client *tg.Client, chatID tg.ChatID) based.Goroutine {
        return based.Go(ctx, func(ctx context.Context) {
                ticker := time.NewTicker(t.config.Typing)
                defer ticker.Stop()
                for {
                        select {
                        case <-ctx.Done():
                                return
                        case <-ticker.C:
                                _ = client.SendChatAction(chatID, tg.ChatActionTyping).DoVoid(ctx)
                        }
                }
        })
}

func (t *Trigger) Allow(ctx context.Context, update *tgb.Update) (bool, error) {
        _, ok := t.getUserID(update.Message.From)
        return ok, nil
}

func (t *Trigger) getUserID(user *tg.User) (string, bool) {
        if userID, ok := t.users[user.ID]; ok {
                return userID, true
        }

        return "", false
}

func withBoundContext(handler tgb.Handler) tgb.Handler {
        return tgb.HandlerFunc(func(ctx context.Context, update *tgb.Update) error {
                ctx, cancel := context.WithCancel(ctx)
                defer cancel()
                return handler.Handle(ctx, update)
        })
}

package triggers

import (
        "context"
        "log/slog"
        "time"

        "github.com/jfk9w-go/based"
        "go.uber.org/multierr"

        "github.com/jfk9w/hoarder/internal/jobs"
        "github.com/jfk9w/hoarder/internal/logs"
)

type Jobs interface {
        Info() []jobs.Info
        Run(ctx jobs.Context, now time.Time, userID string, jobIDs []string) []jobs.Result
}

type Interface interface {
        ID() string
        Run(ctx Context, jobs Jobs)
}

type Registry struct {
        triggers   []Interface
        goroutines []based.Goroutine
        log        *slog.Logger
}

func NewRegistry(log *slog.Logger) *Registry {
        return &Registry{
                log: log,
        }
}

func (r *Registry) Register(trigger Interface) {
        r.triggers = append(r.triggers, trigger)
}

func (r *Registry) Run(ctx context.Context, job Jobs) {
        for _, trigger := range r.triggers {
                log := r.log.With("trigger", trigger.ID())
                goroutine := based.Go(ctx, func(ctx context.Context) {
                        log.Info("trigger started")
                        defer log.Info("trigger stopped")
                        trigger.Run(NewContext(ctx, log), job)
                })

                go func() {
                        if err := goroutine.Join(ctx); err != nil {
                                log.Error("panic in trigger", logs.Error(err))
                        }
                }()

                r.goroutines = append(r.goroutines, goroutine)
        }
}

func (r *Registry) Close() (errs error) {
        for _, goroutine := range r.goroutines {
                goroutine.Cancel()
                err := goroutine.Join(context.Background())
                _ = multierr.AppendInto(&errs, err)
        }

        return
}

package xmpp

import (
        "context"
        "fmt"
        "strings"
        "sync"
        "time"

        "github.com/jfk9w-go/based"
        "github.com/pkg/errors"
        "go.uber.org/multierr"
        "gosrc.io/xmpp"
        "gosrc.io/xmpp/stanza"

        "github.com/jfk9w/hoarder/internal/common"
        "github.com/jfk9w/hoarder/internal/jobs"
        "github.com/jfk9w/hoarder/internal/logs"
        "github.com/jfk9w/hoarder/internal/triggers"
)

const TriggerID = "xmpp"

type Config struct {
        Jid      string                         `yaml:"jid" doc:"JID бота."`
        Password string                         `yaml:"password" doc:"Пароль."`
        Users    common.UserMap[string, string] `yaml:"users" doc:"Маппинг пользователей в JID."`
        Presence time.Duration                  `yaml:"presence,omitempty" doc:"Интервал для отправки присутствия." default:"1m"`
        State    time.Duration                  `yaml:"state,omitempty" doc:"Интервал для отправки состояния (\"печатает\")." default:"5s"`
}

type TriggerParams struct {
        Clock  based.Clock `validate:"required"`
        Config Config      `validate:"required"`
}

type Trigger struct {
        clock  based.Clock
        config Config
        users  map[string]string

        questions common.Questions[string, string]
        requests  sync.WaitGroup
        presence  based.Goroutine
        mu        sync.Mutex
}

func NewTrigger(params TriggerParams) (*Trigger, error) {
        if err := based.Validate(params); err != nil {
                return nil, err
        }

        users, err := params.Config.Users.Reverse()
        if err != nil {
                return nil, errors.Wrap(err, "parse users")
        }

        return &Trigger{
                clock:     params.Clock,
                config:    params.Config,
                users:     users,
                questions: common.NewQuestions[string, string](),
        }, nil
}

func (t *Trigger) ID() string {
        return TriggerID
}

func (t *Trigger) Run(ctx triggers.Context, jobs triggers.Jobs) {
        router := xmpp.NewRouter()
        router.HandleFunc("message", func(sender xmpp.Sender, packet stanza.Packet) {
                message, ok := packet.(stanza.Message)
                if !ok || message.Body == "" {
                        return
                }

                isKnownJid := false
                for jid := range t.users {
                        if strings.HasPrefix(message.From, jid) {
                                message.From = jid
                                isKnownJid = true
                                break
                        }
                }

                if !isKnownJid {
                        return
                }

                t.handleMessage(ctx, sender, message, jobs)
        })

        config := &xmpp.Config{
                Jid:        t.config.Jid,
                Credential: xmpp.Password(t.config.Password),
        }

        client, err := xmpp.NewClient(config, router, func(err error) {
                ctx.Error("client error", logs.Error(err))
        })

        if err != nil {
                ctx.Error("failed to create client", logs.Error(err))
                return
        }

        cm := xmpp.NewStreamManager(client, func(sender xmpp.Sender) {
                ticker := time.NewTicker(t.config.Presence)
                t.presence = based.Go(ctx, func(cctx context.Context) {
                        ctx := triggers.ContextFrom(cctx)
                        defer t.sendPresence(ctx, sender, stanza.PresenceShowXA)
                        defer ticker.Stop()
                        for {
                                t.sendPresence(ctx, sender, stanza.PresenceShowChat)
                                select {
                                case <-ticker.C:
                                        continue
                                case <-ctx.Done():
                                        return
                                }
                        }
                })
        })

        _ = based.Go(ctx, func(_ context.Context) {
                if err := cm.Run(); err != nil {
                        ctx.Error("stream manager finished with error", logs.Error(err))
                        return
                }

                ctx.Debug("stream manager finished OK")
        })

        defer cm.Stop()

        <-ctx.Done()
        t.requests.Wait()
}

func (t *Trigger) handleMessage(ctx triggers.Context, sender xmpp.Sender, message stanza.Message, jobs triggers.Jobs) {
        t.mu.Lock()
        select {
        case <-ctx.Done():
                t.mu.Unlock()
                _ = t.sendMessage(ctx, sender, message.From, "going down, try again later")
                return
        default:
                t.requests.Add(1)
                t.mu.Unlock()
                defer t.requests.Done()
        }

        userID := t.users[message.From]
        ctx = ctx.As(userID)

        err := t.questions.Answer(ctx, userID, message.Body)
        switch {
        case err == nil:
                return

        case errors.Is(err, common.ErrNoQuestions):
                typing := t.startTyping(ctx, sender, message.From)

                askFn := t.askFn(sender, message.From)
                results := jobs.Run(ctx.Job().WithAskFn(askFn), t.clock.Now(), userID, strings.Fields(message.Body))

                var reply strings.Builder
                for _, result := range results {
                        if result.Error == nil {
                                reply.WriteString("✔ ")
                                reply.WriteString(result.JobID)
                                reply.WriteRune('\n')
                        } else {
                                for _, err := range multierr.Errors(result.Error) {
                                        reply.WriteString("✘ ")
                                        reply.WriteString(result.JobID)
                                        reply.WriteString(": ")
                                        reply.WriteString(err.Error())
                                        reply.WriteRune('\n')
                                }
                        }
                }

                typing.Cancel()
                _ = typing.Join(ctx)

                _ = t.sendMessage(ctx, sender, message.From, reply.String())

        default:
                _ = t.sendMessage(ctx, sender, message.From, err.Error())
        }
}

func (t *Trigger) askFn(sender xmpp.Sender, to string) jobs.AskFunc {
        userID := t.users[to]
        return func(ctx context.Context, text string) (string, error) {
                return t.questions.Ask(ctx, userID, func(ctx context.Context, userID string) error {
                        return t.sendMessage(ctx, sender, to, text)
                })
        }
}

func (t *Trigger) startTyping(ctx triggers.Context, sender xmpp.Sender, to string) based.Goroutine {
        ticker := time.NewTicker(t.config.State)
        return based.Go(ctx, func(cctx context.Context) {
                ctx := triggers.ContextFrom(cctx)
                defer t.sendState(ctx, sender, to, stanza.StateInactive{})
                defer ticker.Stop()

                for {
                        t.sendState(ctx, sender, to, stanza.StateComposing{})

                        select {
                        case <-ticker.C:
                                continue
                        case <-ctx.Done():
                                return
                        }
                }
        })
}

func (t *Trigger) sendMessage(cctx context.Context, sender xmpp.Sender, to string, text string) error {
        message := stanza.NewMessage(stanza.Attrs{From: t.config.Jid, To: to})
        message.Body = text

        ctx := triggers.ContextFrom(cctx).With("to", to).With("text", text)
        if err := sender.Send(message); err != nil {
                ctx.Error("failed to send message", logs.Error(err))
                return errors.New("failed to send message")
        }

        ctx.Debug("sent message")
        return nil
}

func (t *Trigger) sendPresence(cctx context.Context, sender xmpp.Sender, show stanza.PresenceShow) {
        ctx := triggers.ContextFrom(cctx).With("show", show)
        for to := range t.users {
                presence := stanza.NewPresence(stanza.Attrs{From: t.config.Jid, To: to})
                presence.Show = show

                ctx := ctx.With("to", to)
                if err := sender.Send(presence); err != nil {
                        ctx.Error("failed to send presence", logs.Error(err))
                        continue
                }

                ctx.Debug("sent presence")
        }
}

func (t *Trigger) sendState(ctx triggers.Context, sender xmpp.Sender, to string, state stanza.MsgExtension) {
        message := stanza.NewMessage(stanza.Attrs{From: t.config.Jid, To: to})
        message.Extensions = append(message.Extensions, state)

        ctx = ctx.With("to", to).With("state", fmt.Sprintf("%T", state))
        if err := sender.Send(message); err != nil {
                ctx.Error("failed to send state", logs.Error(err))
                return
        }

        ctx.Debug("sent state")
}