payments/pkg/client/models/components/v3updateconnectorrequest.go

// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.

package components

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/hanzo-fi/payments/pkg/client/internal/utils"
)

type V3UpdateConnectorRequestType string

const (
	V3UpdateConnectorRequestTypeAdyen         V3UpdateConnectorRequestType = "Adyen"
	V3UpdateConnectorRequestTypeAtlar         V3UpdateConnectorRequestType = "Atlar"
	V3UpdateConnectorRequestTypeBankingbridge V3UpdateConnectorRequestType = "Bankingbridge"
	V3UpdateConnectorRequestTypeBankingcircle V3UpdateConnectorRequestType = "Bankingcircle"
	V3UpdateConnectorRequestTypeBitstamp      V3UpdateConnectorRequestType = "Bitstamp"
	V3UpdateConnectorRequestTypeCoinbaseprime V3UpdateConnectorRequestType = "Coinbaseprime"
	V3UpdateConnectorRequestTypeColumn        V3UpdateConnectorRequestType = "Column"
	V3UpdateConnectorRequestTypeCurrencycloud V3UpdateConnectorRequestType = "Currencycloud"
	V3UpdateConnectorRequestTypeDummypay      V3UpdateConnectorRequestType = "Dummypay"
	V3UpdateConnectorRequestTypeFireblocks    V3UpdateConnectorRequestType = "Fireblocks"
	V3UpdateConnectorRequestTypeGeneric       V3UpdateConnectorRequestType = "Generic"
	V3UpdateConnectorRequestTypeIncrease      V3UpdateConnectorRequestType = "Increase"
	V3UpdateConnectorRequestTypeMangopay      V3UpdateConnectorRequestType = "Mangopay"
	V3UpdateConnectorRequestTypeModulr        V3UpdateConnectorRequestType = "Modulr"
	V3UpdateConnectorRequestTypeMoneycorp     V3UpdateConnectorRequestType = "Moneycorp"
	V3UpdateConnectorRequestTypePlaid         V3UpdateConnectorRequestType = "Plaid"
	V3UpdateConnectorRequestTypePowens        V3UpdateConnectorRequestType = "Powens"
	V3UpdateConnectorRequestTypeQonto         V3UpdateConnectorRequestType = "Qonto"
	V3UpdateConnectorRequestTypeRoutable      V3UpdateConnectorRequestType = "Routable"
	V3UpdateConnectorRequestTypeStripe        V3UpdateConnectorRequestType = "Stripe"
	V3UpdateConnectorRequestTypeTink          V3UpdateConnectorRequestType = "Tink"
	V3UpdateConnectorRequestTypeWise          V3UpdateConnectorRequestType = "Wise"
)

type V3UpdateConnectorRequest struct {
	V3AdyenConfig         *V3AdyenConfig         `queryParam:"inline"`
	V3AtlarConfig         *V3AtlarConfig         `queryParam:"inline"`
	V3BankingcircleConfig *V3BankingcircleConfig `queryParam:"inline"`
	V3ColumnConfig        *V3ColumnConfig        `queryParam:"inline"`
	V3CurrencycloudConfig *V3CurrencycloudConfig `queryParam:"inline"`
	V3DummypayConfig      *V3DummypayConfig      `queryParam:"inline"`
	V3GenericConfig       *V3GenericConfig       `queryParam:"inline"`
	V3IncreaseConfig      *V3IncreaseConfig      `queryParam:"inline"`
	V3MangopayConfig      *V3MangopayConfig      `queryParam:"inline"`
	V3ModulrConfig        *V3ModulrConfig        `queryParam:"inline"`
	V3MoneycorpConfig     *V3MoneycorpConfig     `queryParam:"inline"`
	V3PlaidConfig         *V3PlaidConfig         `queryParam:"inline"`
	V3PowensConfig        *V3PowensConfig        `queryParam:"inline"`
	V3QontoConfig         *V3QontoConfig         `queryParam:"inline"`
	V3StripeConfig        *V3StripeConfig        `queryParam:"inline"`
	V3TinkConfig          *V3TinkConfig          `queryParam:"inline"`
	V3WiseConfig          *V3WiseConfig          `queryParam:"inline"`
	V3BankingbridgeConfig *V3BankingbridgeConfig `queryParam:"inline"`
	V3BitstampConfig      *V3BitstampConfig      `queryParam:"inline"`
	V3CoinbaseprimeConfig *V3CoinbaseprimeConfig `queryParam:"inline"`
	V3FireblocksConfig    *V3FireblocksConfig    `queryParam:"inline"`
	V3RoutableConfig      *V3RoutableConfig      `queryParam:"inline"`

	Type V3UpdateConnectorRequestType
}

func CreateV3UpdateConnectorRequestAdyen(adyen V3AdyenConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeAdyen

	typStr := string(typ)
	adyen.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3AdyenConfig: &adyen,
		Type:          typ,
	}
}

func CreateV3UpdateConnectorRequestAtlar(atlar V3AtlarConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeAtlar

	typStr := string(typ)
	atlar.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3AtlarConfig: &atlar,
		Type:          typ,
	}
}

func CreateV3UpdateConnectorRequestBankingbridge(bankingbridge V3BankingbridgeConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeBankingbridge

	typStr := string(typ)
	bankingbridge.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3BankingbridgeConfig: &bankingbridge,
		Type:                  typ,
	}
}

func CreateV3UpdateConnectorRequestBankingcircle(bankingcircle V3BankingcircleConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeBankingcircle

	typStr := string(typ)
	bankingcircle.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3BankingcircleConfig: &bankingcircle,
		Type:                  typ,
	}
}

func CreateV3UpdateConnectorRequestBitstamp(bitstamp V3BitstampConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeBitstamp

	typStr := string(typ)
	bitstamp.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3BitstampConfig: &bitstamp,
		Type:             typ,
	}
}

func CreateV3UpdateConnectorRequestCoinbaseprime(coinbaseprime V3CoinbaseprimeConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeCoinbaseprime

	typStr := string(typ)
	coinbaseprime.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3CoinbaseprimeConfig: &coinbaseprime,
		Type:                  typ,
	}
}

func CreateV3UpdateConnectorRequestColumn(column V3ColumnConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeColumn

	typStr := string(typ)
	column.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3ColumnConfig: &column,
		Type:           typ,
	}
}

func CreateV3UpdateConnectorRequestCurrencycloud(currencycloud V3CurrencycloudConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeCurrencycloud

	typStr := string(typ)
	currencycloud.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3CurrencycloudConfig: &currencycloud,
		Type:                  typ,
	}
}

func CreateV3UpdateConnectorRequestDummypay(dummypay V3DummypayConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeDummypay

	typStr := string(typ)
	dummypay.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3DummypayConfig: &dummypay,
		Type:             typ,
	}
}

func CreateV3UpdateConnectorRequestFireblocks(fireblocks V3FireblocksConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeFireblocks

	typStr := string(typ)
	fireblocks.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3FireblocksConfig: &fireblocks,
		Type:               typ,
	}
}

func CreateV3UpdateConnectorRequestGeneric(generic V3GenericConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeGeneric

	typStr := string(typ)
	generic.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3GenericConfig: &generic,
		Type:            typ,
	}
}

func CreateV3UpdateConnectorRequestIncrease(increase V3IncreaseConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeIncrease

	typStr := string(typ)
	increase.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3IncreaseConfig: &increase,
		Type:             typ,
	}
}

func CreateV3UpdateConnectorRequestMangopay(mangopay V3MangopayConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeMangopay

	typStr := string(typ)
	mangopay.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3MangopayConfig: &mangopay,
		Type:             typ,
	}
}

func CreateV3UpdateConnectorRequestModulr(modulr V3ModulrConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeModulr

	typStr := string(typ)
	modulr.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3ModulrConfig: &modulr,
		Type:           typ,
	}
}

func CreateV3UpdateConnectorRequestMoneycorp(moneycorp V3MoneycorpConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeMoneycorp

	typStr := string(typ)
	moneycorp.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3MoneycorpConfig: &moneycorp,
		Type:              typ,
	}
}

func CreateV3UpdateConnectorRequestPlaid(plaid V3PlaidConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypePlaid

	typStr := string(typ)
	plaid.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3PlaidConfig: &plaid,
		Type:          typ,
	}
}

func CreateV3UpdateConnectorRequestPowens(powens V3PowensConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypePowens

	typStr := string(typ)
	powens.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3PowensConfig: &powens,
		Type:           typ,
	}
}

func CreateV3UpdateConnectorRequestQonto(qonto V3QontoConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeQonto

	typStr := string(typ)
	qonto.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3QontoConfig: &qonto,
		Type:          typ,
	}
}

func CreateV3UpdateConnectorRequestRoutable(routable V3RoutableConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeRoutable

	typStr := string(typ)
	routable.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3RoutableConfig: &routable,
		Type:             typ,
	}
}

func CreateV3UpdateConnectorRequestStripe(stripe V3StripeConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeStripe

	typStr := string(typ)
	stripe.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3StripeConfig: &stripe,
		Type:           typ,
	}
}

func CreateV3UpdateConnectorRequestTink(tink V3TinkConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeTink

	typStr := string(typ)
	tink.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3TinkConfig: &tink,
		Type:         typ,
	}
}

func CreateV3UpdateConnectorRequestWise(wise V3WiseConfig) V3UpdateConnectorRequest {
	typ := V3UpdateConnectorRequestTypeWise

	typStr := string(typ)
	wise.Provider = &typStr

	return V3UpdateConnectorRequest{
		V3WiseConfig: &wise,
		Type:         typ,
	}
}

func (u *V3UpdateConnectorRequest) UnmarshalJSON(data []byte) error {

	type discriminator struct {
		Provider string `json:"provider"`
	}

	dis := new(discriminator)
	if err := json.Unmarshal(data, &dis); err != nil {
		return fmt.Errorf("could not unmarshal discriminator: %w", err)
	}

	switch dis.Provider {
	case "Adyen":
		v3AdyenConfig := new(V3AdyenConfig)
		if err := utils.UnmarshalJSON(data, &v3AdyenConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Adyen) type V3AdyenConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3AdyenConfig = v3AdyenConfig
		u.Type = V3UpdateConnectorRequestTypeAdyen
		return nil
	case "Atlar":
		v3AtlarConfig := new(V3AtlarConfig)
		if err := utils.UnmarshalJSON(data, &v3AtlarConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Atlar) type V3AtlarConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3AtlarConfig = v3AtlarConfig
		u.Type = V3UpdateConnectorRequestTypeAtlar
		return nil
	case "Bankingbridge":
		v3BankingbridgeConfig := new(V3BankingbridgeConfig)
		if err := utils.UnmarshalJSON(data, &v3BankingbridgeConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Bankingbridge) type V3BankingbridgeConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3BankingbridgeConfig = v3BankingbridgeConfig
		u.Type = V3UpdateConnectorRequestTypeBankingbridge
		return nil
	case "Bankingcircle":
		v3BankingcircleConfig := new(V3BankingcircleConfig)
		if err := utils.UnmarshalJSON(data, &v3BankingcircleConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Bankingcircle) type V3BankingcircleConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3BankingcircleConfig = v3BankingcircleConfig
		u.Type = V3UpdateConnectorRequestTypeBankingcircle
		return nil
	case "Bitstamp":
		v3BitstampConfig := new(V3BitstampConfig)
		if err := utils.UnmarshalJSON(data, &v3BitstampConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Bitstamp) type V3BitstampConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3BitstampConfig = v3BitstampConfig
		u.Type = V3UpdateConnectorRequestTypeBitstamp
		return nil
	case "Coinbaseprime":
		v3CoinbaseprimeConfig := new(V3CoinbaseprimeConfig)
		if err := utils.UnmarshalJSON(data, &v3CoinbaseprimeConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Coinbaseprime) type V3CoinbaseprimeConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3CoinbaseprimeConfig = v3CoinbaseprimeConfig
		u.Type = V3UpdateConnectorRequestTypeCoinbaseprime
		return nil
	case "Column":
		v3ColumnConfig := new(V3ColumnConfig)
		if err := utils.UnmarshalJSON(data, &v3ColumnConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Column) type V3ColumnConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3ColumnConfig = v3ColumnConfig
		u.Type = V3UpdateConnectorRequestTypeColumn
		return nil
	case "Currencycloud":
		v3CurrencycloudConfig := new(V3CurrencycloudConfig)
		if err := utils.UnmarshalJSON(data, &v3CurrencycloudConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Currencycloud) type V3CurrencycloudConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3CurrencycloudConfig = v3CurrencycloudConfig
		u.Type = V3UpdateConnectorRequestTypeCurrencycloud
		return nil
	case "Dummypay":
		v3DummypayConfig := new(V3DummypayConfig)
		if err := utils.UnmarshalJSON(data, &v3DummypayConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Dummypay) type V3DummypayConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3DummypayConfig = v3DummypayConfig
		u.Type = V3UpdateConnectorRequestTypeDummypay
		return nil
	case "Fireblocks":
		v3FireblocksConfig := new(V3FireblocksConfig)
		if err := utils.UnmarshalJSON(data, &v3FireblocksConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Fireblocks) type V3FireblocksConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3FireblocksConfig = v3FireblocksConfig
		u.Type = V3UpdateConnectorRequestTypeFireblocks
		return nil
	case "Generic":
		v3GenericConfig := new(V3GenericConfig)
		if err := utils.UnmarshalJSON(data, &v3GenericConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Generic) type V3GenericConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3GenericConfig = v3GenericConfig
		u.Type = V3UpdateConnectorRequestTypeGeneric
		return nil
	case "Increase":
		v3IncreaseConfig := new(V3IncreaseConfig)
		if err := utils.UnmarshalJSON(data, &v3IncreaseConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Increase) type V3IncreaseConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3IncreaseConfig = v3IncreaseConfig
		u.Type = V3UpdateConnectorRequestTypeIncrease
		return nil
	case "Mangopay":
		v3MangopayConfig := new(V3MangopayConfig)
		if err := utils.UnmarshalJSON(data, &v3MangopayConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Mangopay) type V3MangopayConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3MangopayConfig = v3MangopayConfig
		u.Type = V3UpdateConnectorRequestTypeMangopay
		return nil
	case "Modulr":
		v3ModulrConfig := new(V3ModulrConfig)
		if err := utils.UnmarshalJSON(data, &v3ModulrConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Modulr) type V3ModulrConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3ModulrConfig = v3ModulrConfig
		u.Type = V3UpdateConnectorRequestTypeModulr
		return nil
	case "Moneycorp":
		v3MoneycorpConfig := new(V3MoneycorpConfig)
		if err := utils.UnmarshalJSON(data, &v3MoneycorpConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Moneycorp) type V3MoneycorpConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3MoneycorpConfig = v3MoneycorpConfig
		u.Type = V3UpdateConnectorRequestTypeMoneycorp
		return nil
	case "Plaid":
		v3PlaidConfig := new(V3PlaidConfig)
		if err := utils.UnmarshalJSON(data, &v3PlaidConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Plaid) type V3PlaidConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3PlaidConfig = v3PlaidConfig
		u.Type = V3UpdateConnectorRequestTypePlaid
		return nil
	case "Powens":
		v3PowensConfig := new(V3PowensConfig)
		if err := utils.UnmarshalJSON(data, &v3PowensConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Powens) type V3PowensConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3PowensConfig = v3PowensConfig
		u.Type = V3UpdateConnectorRequestTypePowens
		return nil
	case "Qonto":
		v3QontoConfig := new(V3QontoConfig)
		if err := utils.UnmarshalJSON(data, &v3QontoConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Qonto) type V3QontoConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3QontoConfig = v3QontoConfig
		u.Type = V3UpdateConnectorRequestTypeQonto
		return nil
	case "Routable":
		v3RoutableConfig := new(V3RoutableConfig)
		if err := utils.UnmarshalJSON(data, &v3RoutableConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Routable) type V3RoutableConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3RoutableConfig = v3RoutableConfig
		u.Type = V3UpdateConnectorRequestTypeRoutable
		return nil
	case "Stripe":
		v3StripeConfig := new(V3StripeConfig)
		if err := utils.UnmarshalJSON(data, &v3StripeConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Stripe) type V3StripeConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3StripeConfig = v3StripeConfig
		u.Type = V3UpdateConnectorRequestTypeStripe
		return nil
	case "Tink":
		v3TinkConfig := new(V3TinkConfig)
		if err := utils.UnmarshalJSON(data, &v3TinkConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Tink) type V3TinkConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3TinkConfig = v3TinkConfig
		u.Type = V3UpdateConnectorRequestTypeTink
		return nil
	case "Wise":
		v3WiseConfig := new(V3WiseConfig)
		if err := utils.UnmarshalJSON(data, &v3WiseConfig, "", true, false); err != nil {
			return fmt.Errorf("could not unmarshal `%s` into expected (Provider == Wise) type V3WiseConfig within V3UpdateConnectorRequest: %w", string(data), err)
		}

		u.V3WiseConfig = v3WiseConfig
		u.Type = V3UpdateConnectorRequestTypeWise
		return nil
	}

	return fmt.Errorf("could not unmarshal `%s` into any supported union types for V3UpdateConnectorRequest", string(data))
}

func (u V3UpdateConnectorRequest) MarshalJSON() ([]byte, error) {
	if u.V3AdyenConfig != nil {
		return utils.MarshalJSON(u.V3AdyenConfig, "", true)
	}

	if u.V3AtlarConfig != nil {
		return utils.MarshalJSON(u.V3AtlarConfig, "", true)
	}

	if u.V3BankingcircleConfig != nil {
		return utils.MarshalJSON(u.V3BankingcircleConfig, "", true)
	}

	if u.V3ColumnConfig != nil {
		return utils.MarshalJSON(u.V3ColumnConfig, "", true)
	}

	if u.V3CurrencycloudConfig != nil {
		return utils.MarshalJSON(u.V3CurrencycloudConfig, "", true)
	}

	if u.V3DummypayConfig != nil {
		return utils.MarshalJSON(u.V3DummypayConfig, "", true)
	}

	if u.V3GenericConfig != nil {
		return utils.MarshalJSON(u.V3GenericConfig, "", true)
	}

	if u.V3IncreaseConfig != nil {
		return utils.MarshalJSON(u.V3IncreaseConfig, "", true)
	}

	if u.V3MangopayConfig != nil {
		return utils.MarshalJSON(u.V3MangopayConfig, "", true)
	}

	if u.V3ModulrConfig != nil {
		return utils.MarshalJSON(u.V3ModulrConfig, "", true)
	}

	if u.V3MoneycorpConfig != nil {
		return utils.MarshalJSON(u.V3MoneycorpConfig, "", true)
	}

	if u.V3PlaidConfig != nil {
		return utils.MarshalJSON(u.V3PlaidConfig, "", true)
	}

	if u.V3PowensConfig != nil {
		return utils.MarshalJSON(u.V3PowensConfig, "", true)
	}

	if u.V3QontoConfig != nil {
		return utils.MarshalJSON(u.V3QontoConfig, "", true)
	}

	if u.V3StripeConfig != nil {
		return utils.MarshalJSON(u.V3StripeConfig, "", true)
	}

	if u.V3TinkConfig != nil {
		return utils.MarshalJSON(u.V3TinkConfig, "", true)
	}

	if u.V3WiseConfig != nil {
		return utils.MarshalJSON(u.V3WiseConfig, "", true)
	}

	if u.V3BankingbridgeConfig != nil {
		return utils.MarshalJSON(u.V3BankingbridgeConfig, "", true)
	}

	if u.V3BitstampConfig != nil {
		return utils.MarshalJSON(u.V3BitstampConfig, "", true)
	}

	if u.V3CoinbaseprimeConfig != nil {
		return utils.MarshalJSON(u.V3CoinbaseprimeConfig, "", true)
	}

	if u.V3FireblocksConfig != nil {
		return utils.MarshalJSON(u.V3FireblocksConfig, "", true)
	}

	if u.V3RoutableConfig != nil {
		return utils.MarshalJSON(u.V3RoutableConfig, "", true)
	}

	return nil, errors.New("could not marshal union type V3UpdateConnectorRequest: all fields are null")
}