zerotier-one-api-spec/examples/go/client/client.gen.go

// Package client provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.3.0 DO NOT EDIT.
package client

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"

	"github.com/oapi-codegen/runtime"
)

const (
	ApiKeyAuthScopes = "ApiKeyAuth.Scopes"
)

// Defines values for ControllerNetworkObjtype.
const (
	Network ControllerNetworkObjtype = "network"
)

// Defines values for ControllerNetworkMemberObjtype.
const (
	Member ControllerNetworkMemberObjtype = "member"
)

// Defines values for ControllerNetworkMemberVMajor1.
const (
	ControllerNetworkMemberVMajor1Minus1 ControllerNetworkMemberVMajor1 = -1
)

// Defines values for ControllerNetworkMemberVMinor1.
const (
	ControllerNetworkMemberVMinor1Minus1 ControllerNetworkMemberVMinor1 = -1
)

// Defines values for ControllerNetworkMemberVProto1.
const (
	ControllerNetworkMemberVProto1Minus1 ControllerNetworkMemberVProto1 = -1
)

// Defines values for ControllerNetworkMemberVRev1.
const (
	ControllerNetworkMemberVRev1Minus1 ControllerNetworkMemberVRev1 = -1
)

// Defines values for ControllerStatusController.
const (
	ControllerStatusControllerTrue ControllerStatusController = true
)

// Defines values for LeaveResultResult.
const (
	LeaveResultResultTrue LeaveResultResult = true
)

// Defines values for NetworkDNSDomain1.
const (
	Empty NetworkDNSDomain1 = ""
)

// Defines values for NodeStatusVersionBuild1.
const (
	NodeStatusVersionBuild1Minus1 NodeStatusVersionBuild1 = -1
)

// Defines values for NodeStatusVersionMajor1.
const (
	NodeStatusVersionMajor1Minus1 NodeStatusVersionMajor1 = -1
)

// Defines values for NodeStatusVersionMinor1.
const (
	NodeStatusVersionMinor1Minus1 NodeStatusVersionMinor1 = -1
)

// Defines values for NodeStatusVersionRev1.
const (
	NodeStatusVersionRev1Minus1 NodeStatusVersionRev1 = -1
)

// Defines values for PeerLatency1.
const (
	PeerLatency1Minus1 PeerLatency1 = -1
)

// Defines values for PeerRole.
const (
	LEAF   PeerRole = "LEAF"
	MOON   PeerRole = "MOON"
	PLANET PeerRole = "PLANET"
)

// Defines values for PeerVersionMajor1.
const (
	PeerVersionMajor1Minus1 PeerVersionMajor1 = -1
)

// Defines values for PeerVersionMinor1.
const (
	PeerVersionMinor1Minus1 PeerVersionMinor1 = -1
)

// Defines values for PeerVersionRev1.
const (
	PeerVersionRev1Minus1 PeerVersionRev1 = -1
)

// ControllerNetwork defines model for ControllerNetwork.
type ControllerNetwork struct {
	Capabilities      NetworkCapsItem       `json:"capabilities"`
	CreationTime      USafeint              `json:"creationTime"`
	Dns               ControllerNetwork_Dns `json:"dns"`
	EnableBroadcast   bool                  `json:"enableBroadcast"`
	Id                ZTNetworkID           `json:"id"`
	IpAssignmentPools []struct {
		IpRangeEnd   ControllerNetwork_IpAssignmentPools_IpRangeEnd   `json:"ipRangeEnd"`
		IpRangeStart ControllerNetwork_IpAssignmentPools_IpRangeStart `json:"ipRangeStart"`
	} `json:"ipAssignmentPools"`
	Mtu            MTU                      `json:"mtu"`
	MulticastLimit USafeint                 `json:"multicastLimit"`
	Name           string                   `json:"name"`
	Nwid           ZTNetworkID              `json:"nwid"`
	Objtype        ControllerNetworkObjtype `json:"objtype"`
	Private        bool                     `json:"private"`
	Revision       USafeint                 `json:"revision"`
	Routes         []struct {
		Target ControllerNetwork_Routes_Target `json:"target"`
		Via    *ControllerNetwork_Routes_Via   `json:"via"`
	} `json:"routes"`
	Rules        []NetworkRule   `json:"rules"`
	Tags         NetworkTagsItem `json:"tags"`
	V4AssignMode struct {
		Zt *bool `json:"zt,omitempty"`
	} `json:"v4AssignMode"`
	V6AssignMode struct {
		N6plane *bool `json:"6plane,omitempty"`
		Rfc4193 *bool `json:"rfc4193,omitempty"`
		Zt      *bool `json:"zt,omitempty"`
	} `json:"v6AssignMode"`
}

// ControllerNetwork_Dns defines model for ControllerNetwork.Dns.
type ControllerNetwork_Dns struct {
	union json.RawMessage
}

// ControllerNetwork_IpAssignmentPools_IpRangeEnd defines model for ControllerNetwork.IpAssignmentPools.IpRangeEnd.
type ControllerNetwork_IpAssignmentPools_IpRangeEnd struct {
	union json.RawMessage
}

// ControllerNetwork_IpAssignmentPools_IpRangeStart defines model for ControllerNetwork.IpAssignmentPools.IpRangeStart.
type ControllerNetwork_IpAssignmentPools_IpRangeStart struct {
	union json.RawMessage
}

// ControllerNetworkObjtype defines model for ControllerNetwork.Objtype.
type ControllerNetworkObjtype string

// ControllerNetwork_Routes_Target defines model for ControllerNetwork.Routes.Target.
type ControllerNetwork_Routes_Target struct {
	union json.RawMessage
}

// ControllerNetwork_Routes_Via defines model for ControllerNetwork.Routes.Via.
type ControllerNetwork_Routes_Via struct {
	union json.RawMessage
}

// ControllerNetworkIDList defines model for ControllerNetworkIDList.
type ControllerNetworkIDList = []ZTNetworkID

// ControllerNetworkMember defines model for ControllerNetworkMember.
type ControllerNetworkMember struct {
	ActiveBridge                 *bool                                         `json:"activeBridge,omitempty"`
	Address                      ZTAddress                                     `json:"address"`
	AuthenticationExpiryTime     USafeint                                      `json:"authenticationExpiryTime"`
	Authorized                   *bool                                         `json:"authorized,omitempty"`
	Capabilities                 []USafeint                                    `json:"capabilities"`
	CreationTime                 USafeint                                      `json:"creationTime"`
	Id                           ZTAddress                                     `json:"id"`
	Identity                     *string                                       `json:"identity,omitempty"`
	IpAssignments                *[]ControllerNetworkMember_IpAssignments_Item `json:"ipAssignments,omitempty"`
	LastAuthorizedCredential     *string                                       `json:"lastAuthorizedCredential"`
	LastAuthorizedCredentialType string                                        `json:"lastAuthorizedCredentialType"`
	LastAuthorizedTime           USafeint                                      `json:"lastAuthorizedTime"`
	LastDeauthorizedTime         USafeint                                      `json:"lastDeauthorizedTime"`
	Name                         *string                                       `json:"name,omitempty"`
	NoAutoAssignIps              *bool                                         `json:"noAutoAssignIps,omitempty"`
	Nwid                         ZTNetworkID                                   `json:"nwid"`
	Objtype                      ControllerNetworkMemberObjtype                `json:"objtype"`
	RemoteTraceLevel             USafeint                                      `json:"remoteTraceLevel"`
	RemoteTraceTarget            *string                                       `json:"remoteTraceTarget"`
	Revision                     VersionDigit                                  `json:"revision"`
	SsoExempt                    *bool                                         `json:"ssoExempt,omitempty"`
	Tags                         interface{}                                   `json:"tags"`
	VMajor                       ControllerNetworkMember_VMajor                `json:"vMajor"`
	VMinor                       ControllerNetworkMember_VMinor                `json:"vMinor"`
	VProto                       ControllerNetworkMember_VProto                `json:"vProto"`
	VRev                         ControllerNetworkMember_VRev                  `json:"vRev"`
}

// ControllerNetworkMember_IpAssignments_Item defines model for ControllerNetworkMember.ipAssignments.Item.
type ControllerNetworkMember_IpAssignments_Item struct {
	union json.RawMessage
}

// ControllerNetworkMemberObjtype defines model for ControllerNetworkMember.Objtype.
type ControllerNetworkMemberObjtype string

// ControllerNetworkMemberVMajor1 defines model for ControllerNetworkMember.VMajor.1.
type ControllerNetworkMemberVMajor1 float32

// ControllerNetworkMember_VMajor defines model for ControllerNetworkMember.VMajor.
type ControllerNetworkMember_VMajor struct {
	union json.RawMessage
}

// ControllerNetworkMemberVMinor1 defines model for ControllerNetworkMember.VMinor.1.
type ControllerNetworkMemberVMinor1 float32

// ControllerNetworkMember_VMinor defines model for ControllerNetworkMember.VMinor.
type ControllerNetworkMember_VMinor struct {
	union json.RawMessage
}

// ControllerNetworkMemberVProto1 defines model for ControllerNetworkMember.VProto.1.
type ControllerNetworkMemberVProto1 float32

// ControllerNetworkMember_VProto defines model for ControllerNetworkMember.VProto.
type ControllerNetworkMember_VProto struct {
	union json.RawMessage
}

// ControllerNetworkMemberVRev1 defines model for ControllerNetworkMember.VRev.1.
type ControllerNetworkMemberVRev1 float32

// ControllerNetworkMember_VRev defines model for ControllerNetworkMember.VRev.
type ControllerNetworkMember_VRev struct {
	union json.RawMessage
}

// ControllerNetworkMemberList defines model for ControllerNetworkMemberList.
type ControllerNetworkMemberList map[string]int32

// ControllerNetworkMemberListFull defines model for ControllerNetworkMemberListFull.
type ControllerNetworkMemberListFull struct {
	Data []ControllerNetworkMember `json:"data"`
	Meta struct {
		AuthorizedCount USafeint `json:"authorizedCount"`
		TotalCount      USafeint `json:"totalCount"`
	} `json:"meta"`
}

// ControllerNetworkMemberRequest defines model for ControllerNetworkMemberRequest.
type ControllerNetworkMemberRequest struct {
	ActiveBridge    *bool                                                `json:"activeBridge,omitempty"`
	Authorized      *bool                                                `json:"authorized,omitempty"`
	IpAssignments   *[]ControllerNetworkMemberRequest_IpAssignments_Item `json:"ipAssignments,omitempty"`
	Name            *string                                              `json:"name,omitempty"`
	NoAutoAssignIps *bool                                                `json:"noAutoAssignIps,omitempty"`
	SsoExempt       *bool                                                `json:"ssoExempt,omitempty"`
}

// ControllerNetworkMemberRequest_IpAssignments_Item defines model for ControllerNetworkMemberRequest.ipAssignments.Item.
type ControllerNetworkMemberRequest_IpAssignments_Item struct {
	union json.RawMessage
}

// ControllerNetworkRequest defines model for ControllerNetworkRequest.
type ControllerNetworkRequest struct {
	Dns               *ControllerNetworkRequest_Dns `json:"dns,omitempty"`
	EnableBroadcast   *bool                         `json:"enableBroadcast,omitempty"`
	IpAssignmentPools *[]struct {
		IpRangeEnd   ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd   `json:"ipRangeEnd"`
		IpRangeStart ControllerNetworkRequest_IpAssignmentPools_IpRangeStart `json:"ipRangeStart"`
	} `json:"ipAssignmentPools,omitempty"`
	Mtu            *MTU      `json:"mtu,omitempty"`
	MulticastLimit *USafeint `json:"multicastLimit,omitempty"`
	Name           *string   `json:"name,omitempty"`
	Private        *bool     `json:"private,omitempty"`
	Routes         *[]struct {
		Target ControllerNetworkRequest_Routes_Target `json:"target"`
		Via    *ControllerNetworkRequest_Routes_Via   `json:"via"`
	} `json:"routes,omitempty"`
	V4AssignMode *struct {
		Zt *bool `json:"zt,omitempty"`
	} `json:"v4AssignMode,omitempty"`
	V6AssignMode *struct {
		N6plane *bool `json:"6plane,omitempty"`
		Rfc4193 *bool `json:"rfc4193,omitempty"`
		Zt      *bool `json:"zt,omitempty"`
	} `json:"v6AssignMode,omitempty"`
}

// ControllerNetworkRequest_Dns defines model for ControllerNetworkRequest.Dns.
type ControllerNetworkRequest_Dns struct {
	union json.RawMessage
}

// ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd defines model for ControllerNetworkRequest.IpAssignmentPools.IpRangeEnd.
type ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd struct {
	union json.RawMessage
}

// ControllerNetworkRequest_IpAssignmentPools_IpRangeStart defines model for ControllerNetworkRequest.IpAssignmentPools.IpRangeStart.
type ControllerNetworkRequest_IpAssignmentPools_IpRangeStart struct {
	union json.RawMessage
}

// ControllerNetworkRequest_Routes_Target defines model for ControllerNetworkRequest.Routes.Target.
type ControllerNetworkRequest_Routes_Target struct {
	union json.RawMessage
}

// ControllerNetworkRequest_Routes_Via defines model for ControllerNetworkRequest.Routes.Via.
type ControllerNetworkRequest_Routes_Via struct {
	union json.RawMessage
}

// ControllerNetworks defines model for ControllerNetworks.
type ControllerNetworks struct {
	Data []ControllerNetwork `json:"data"`
	Meta struct {
		NetworkCount USafeint `json:"networkCount"`
	} `json:"meta"`
}

// ControllerStatus defines model for ControllerStatus.
type ControllerStatus struct {
	ApiVersion    VersionDigit               `json:"apiVersion"`
	Clock         USafeint                   `json:"clock"`
	Controller    ControllerStatusController `json:"controller"`
	DatabaseReady bool                       `json:"databaseReady"`
}

// ControllerStatusController defines model for ControllerStatus.Controller.
type ControllerStatusController bool

// EmptyArrayItem defines model for EmptyArrayItem.
type EmptyArrayItem = []interface{}

// IPSlashPort defines model for IPSlashPort.
type IPSlashPort = string

// IPv4 defines model for IPv4.
type IPv4 = string

// IPv6 defines model for IPv6.
type IPv6 = string

// JoinedNetwork defines model for JoinedNetwork.
type JoinedNetwork map[string]interface{}

// JoinedNetworkRequest defines model for JoinedNetworkRequest.
type JoinedNetworkRequest struct {
	AllowDNS     *bool `json:"allowDNS,omitempty"`
	AllowDefault *bool `json:"allowDefault,omitempty"`
	AllowGlobal  *bool `json:"allowGlobal,omitempty"`
	AllowManaged *bool `json:"allowManaged,omitempty"`
}

// LeaveResult defines model for LeaveResult.
type LeaveResult struct {
	Result LeaveResultResult `json:"result"`
}

// LeaveResultResult defines model for LeaveResult.Result.
type LeaveResultResult bool

// MTU defines model for MTU.
type MTU = uint32

// NetworkCap defines model for NetworkCap.
type NetworkCap = []int

// NetworkCapsItem defines model for NetworkCapsItem.
type NetworkCapsItem = []NetworkCap

// NetworkDNS defines model for NetworkDNS.
type NetworkDNS struct {
	Domain  NetworkDNS_Domain         `json:"domain"`
	Servers []NetworkDNS_Servers_Item `json:"servers"`
}

// NetworkDNSDomain1 defines model for NetworkDNS.Domain.1.
type NetworkDNSDomain1 string

// NetworkDNS_Domain defines model for NetworkDNS.Domain.
type NetworkDNS_Domain struct {
	union json.RawMessage
}

// NetworkDNS_Servers_Item defines model for NetworkDNS.servers.Item.
type NetworkDNS_Servers_Item struct {
	union json.RawMessage
}

// NetworkRule defines model for NetworkRule.
type NetworkRule map[string]interface{}

// NetworkTag defines model for NetworkTag.
type NetworkTag = []int

// NetworkTagsItem defines model for NetworkTagsItem.
type NetworkTagsItem = []NetworkTag

// NodeStatus defines model for NodeStatus.
type NodeStatus struct {
	Address ZTAddress `json:"address"`
	Clock   USafeint  `json:"clock"`
	Config  struct {
		Settings struct {
			AllowManagementFrom   *[]IPSlashPort `json:"allowManagementFrom,omitempty"`
			AllowTcpFallbackRelay bool           `json:"allowTcpFallbackRelay"`
			ForceTcpRelay         bool           `json:"forceTcpRelay"`
			ListeningOn           []IPSlashPort  `json:"listeningOn"`
			PortMappingEnabled    bool           `json:"portMappingEnabled"`
			PrimaryPort           Port           `json:"primaryPort"`
			SecondaryPort         Port           `json:"secondaryPort"`
			SoftwareUpdate        string         `json:"softwareUpdate"`
			SoftwareUpdateChannel string         `json:"softwareUpdateChannel"`
			SurfaceAddresses      []IPSlashPort  `json:"surfaceAddresses"`
			TertiaryPort          Port           `json:"tertiaryPort"`
		} `json:"settings"`
	} `json:"config"`
	Online               bool                    `json:"online"`
	PlanetWorldId        USafeint                `json:"planetWorldId"`
	PlanetWorldTimestamp USafeint                `json:"planetWorldTimestamp"`
	PublicIdentity       string                  `json:"publicIdentity"`
	TcpFallbackActive    bool                    `json:"tcpFallbackActive"`
	Version              string                  `json:"version"`
	VersionBuild         NodeStatus_VersionBuild `json:"versionBuild"`
	VersionMajor         NodeStatus_VersionMajor `json:"versionMajor"`
	VersionMinor         NodeStatus_VersionMinor `json:"versionMinor"`
	VersionRev           NodeStatus_VersionRev   `json:"versionRev"`
}

// NodeStatusVersionBuild1 defines model for NodeStatus.VersionBuild.1.
type NodeStatusVersionBuild1 float32

// NodeStatus_VersionBuild defines model for NodeStatus.VersionBuild.
type NodeStatus_VersionBuild struct {
	union json.RawMessage
}

// NodeStatusVersionMajor1 defines model for NodeStatus.VersionMajor.1.
type NodeStatusVersionMajor1 float32

// NodeStatus_VersionMajor defines model for NodeStatus.VersionMajor.
type NodeStatus_VersionMajor struct {
	union json.RawMessage
}

// NodeStatusVersionMinor1 defines model for NodeStatus.VersionMinor.1.
type NodeStatusVersionMinor1 float32

// NodeStatus_VersionMinor defines model for NodeStatus.VersionMinor.
type NodeStatus_VersionMinor struct {
	union json.RawMessage
}

// NodeStatusVersionRev1 defines model for NodeStatus.VersionRev.1.
type NodeStatusVersionRev1 float32

// NodeStatus_VersionRev defines model for NodeStatus.VersionRev.
type NodeStatus_VersionRev struct {
	union json.RawMessage
}

// Peer defines model for Peer.
type Peer struct {
	Address  ZTAddress    `json:"address"`
	IsBonded bool         `json:"isBonded"`
	Latency  Peer_Latency `json:"latency"`
	Paths    []struct {
		Active        bool        `json:"active"`
		Address       IPSlashPort `json:"address"`
		Expired       bool        `json:"expired"`
		LastReceive   USafeint    `json:"lastReceive"`
		LastSend      USafeint    `json:"lastSend"`
		LocalSocket   USafeint    `json:"localSocket"`
		Preferred     bool        `json:"preferred"`
		TrustedPathId USafeint    `json:"trustedPathId"`
	} `json:"paths"`
	Role         PeerRole          `json:"role"`
	Tunneled     bool              `json:"tunneled"`
	Version      string            `json:"version"`
	VersionMajor Peer_VersionMajor `json:"versionMajor"`
	VersionMinor Peer_VersionMinor `json:"versionMinor"`
	VersionRev   Peer_VersionRev   `json:"versionRev"`
}

// PeerLatency1 defines model for Peer.Latency.1.
type PeerLatency1 float32

// Peer_Latency defines model for Peer.Latency.
type Peer_Latency struct {
	union json.RawMessage
}

// PeerRole defines model for Peer.Role.
type PeerRole string

// PeerVersionMajor1 defines model for Peer.VersionMajor.1.
type PeerVersionMajor1 float32

// Peer_VersionMajor defines model for Peer.VersionMajor.
type Peer_VersionMajor struct {
	union json.RawMessage
}

// PeerVersionMinor1 defines model for Peer.VersionMinor.1.
type PeerVersionMinor1 float32

// Peer_VersionMinor defines model for Peer.VersionMinor.
type Peer_VersionMinor struct {
	union json.RawMessage
}

// PeerVersionRev1 defines model for Peer.VersionRev.1.
type PeerVersionRev1 float32

// Peer_VersionRev defines model for Peer.VersionRev.
type Peer_VersionRev struct {
	union json.RawMessage
}

// Port defines model for Port.
type Port = uint16

// VersionDigit defines model for VersionDigit.
type VersionDigit = uint8

// ZTAddress defines model for ZTAddress.
type ZTAddress = string

// ZTNetworkID defines model for ZTNetworkID.
type ZTNetworkID = string

// Domain defines model for domain.
type Domain = string

// USafeint defines model for uSafeint.
type USafeint = int64

// RandomNetworkRandomNetworkJSONRequestBody defines body for RandomNetworkRandomNetwork for application/json ContentType.
type RandomNetworkRandomNetworkJSONRequestBody = ControllerNetworkRequest

// NetworkPostNetworkJSONRequestBody defines body for NetworkPostNetwork for application/json ContentType.
type NetworkPostNetworkJSONRequestBody = ControllerNetworkRequest

// NetworkMemberPostNetworkMemberJSONRequestBody defines body for NetworkMemberPostNetworkMember for application/json ContentType.
type NetworkMemberPostNetworkMemberJSONRequestBody = ControllerNetworkMemberRequest

// NetworkMembershipSetNetworkJSONRequestBody defines body for NetworkMembershipSetNetwork for application/json ContentType.
type NetworkMembershipSetNetworkJSONRequestBody = JoinedNetworkRequest

// AsNetworkDNS returns the union data inside the ControllerNetwork_Dns as a NetworkDNS
func (t ControllerNetwork_Dns) AsNetworkDNS() (NetworkDNS, error) {
	var body NetworkDNS
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNetworkDNS overwrites any union data inside the ControllerNetwork_Dns as the provided NetworkDNS
func (t *ControllerNetwork_Dns) FromNetworkDNS(v NetworkDNS) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNetworkDNS performs a merge with any union data inside the ControllerNetwork_Dns, using the provided NetworkDNS
func (t *ControllerNetwork_Dns) MergeNetworkDNS(v NetworkDNS) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEmptyArrayItem returns the union data inside the ControllerNetwork_Dns as a EmptyArrayItem
func (t ControllerNetwork_Dns) AsEmptyArrayItem() (EmptyArrayItem, error) {
	var body EmptyArrayItem
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEmptyArrayItem overwrites any union data inside the ControllerNetwork_Dns as the provided EmptyArrayItem
func (t *ControllerNetwork_Dns) FromEmptyArrayItem(v EmptyArrayItem) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEmptyArrayItem performs a merge with any union data inside the ControllerNetwork_Dns, using the provided EmptyArrayItem
func (t *ControllerNetwork_Dns) MergeEmptyArrayItem(v EmptyArrayItem) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetwork_Dns) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetwork_Dns) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd as a IPv4
func (t ControllerNetwork_IpAssignmentPools_IpRangeEnd) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd as the provided IPv4
func (t *ControllerNetwork_IpAssignmentPools_IpRangeEnd) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd, using the provided IPv4
func (t *ControllerNetwork_IpAssignmentPools_IpRangeEnd) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd as a IPv6
func (t ControllerNetwork_IpAssignmentPools_IpRangeEnd) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd as the provided IPv6
func (t *ControllerNetwork_IpAssignmentPools_IpRangeEnd) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeEnd, using the provided IPv6
func (t *ControllerNetwork_IpAssignmentPools_IpRangeEnd) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetwork_IpAssignmentPools_IpRangeEnd) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetwork_IpAssignmentPools_IpRangeEnd) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart as a IPv4
func (t ControllerNetwork_IpAssignmentPools_IpRangeStart) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart as the provided IPv4
func (t *ControllerNetwork_IpAssignmentPools_IpRangeStart) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart, using the provided IPv4
func (t *ControllerNetwork_IpAssignmentPools_IpRangeStart) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart as a IPv6
func (t ControllerNetwork_IpAssignmentPools_IpRangeStart) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart as the provided IPv6
func (t *ControllerNetwork_IpAssignmentPools_IpRangeStart) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetwork_IpAssignmentPools_IpRangeStart, using the provided IPv6
func (t *ControllerNetwork_IpAssignmentPools_IpRangeStart) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetwork_IpAssignmentPools_IpRangeStart) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetwork_IpAssignmentPools_IpRangeStart) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetwork_Routes_Target as a IPv4
func (t ControllerNetwork_Routes_Target) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetwork_Routes_Target as the provided IPv4
func (t *ControllerNetwork_Routes_Target) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetwork_Routes_Target, using the provided IPv4
func (t *ControllerNetwork_Routes_Target) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetwork_Routes_Target as a IPv6
func (t ControllerNetwork_Routes_Target) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetwork_Routes_Target as the provided IPv6
func (t *ControllerNetwork_Routes_Target) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetwork_Routes_Target, using the provided IPv6
func (t *ControllerNetwork_Routes_Target) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetwork_Routes_Target) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetwork_Routes_Target) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetwork_Routes_Via as a IPv4
func (t ControllerNetwork_Routes_Via) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetwork_Routes_Via as the provided IPv4
func (t *ControllerNetwork_Routes_Via) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetwork_Routes_Via, using the provided IPv4
func (t *ControllerNetwork_Routes_Via) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetwork_Routes_Via as a IPv6
func (t ControllerNetwork_Routes_Via) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetwork_Routes_Via as the provided IPv6
func (t *ControllerNetwork_Routes_Via) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetwork_Routes_Via, using the provided IPv6
func (t *ControllerNetwork_Routes_Via) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetwork_Routes_Via) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetwork_Routes_Via) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkMember_IpAssignments_Item as a IPv4
func (t ControllerNetworkMember_IpAssignments_Item) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkMember_IpAssignments_Item as the provided IPv4
func (t *ControllerNetworkMember_IpAssignments_Item) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkMember_IpAssignments_Item, using the provided IPv4
func (t *ControllerNetworkMember_IpAssignments_Item) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkMember_IpAssignments_Item as a IPv6
func (t ControllerNetworkMember_IpAssignments_Item) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkMember_IpAssignments_Item as the provided IPv6
func (t *ControllerNetworkMember_IpAssignments_Item) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkMember_IpAssignments_Item, using the provided IPv6
func (t *ControllerNetworkMember_IpAssignments_Item) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMember_IpAssignments_Item) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMember_IpAssignments_Item) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the ControllerNetworkMember_VMajor as a VersionDigit
func (t ControllerNetworkMember_VMajor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the ControllerNetworkMember_VMajor as the provided VersionDigit
func (t *ControllerNetworkMember_VMajor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the ControllerNetworkMember_VMajor, using the provided VersionDigit
func (t *ControllerNetworkMember_VMajor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsControllerNetworkMemberVMajor1 returns the union data inside the ControllerNetworkMember_VMajor as a ControllerNetworkMemberVMajor1
func (t ControllerNetworkMember_VMajor) AsControllerNetworkMemberVMajor1() (ControllerNetworkMemberVMajor1, error) {
	var body ControllerNetworkMemberVMajor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromControllerNetworkMemberVMajor1 overwrites any union data inside the ControllerNetworkMember_VMajor as the provided ControllerNetworkMemberVMajor1
func (t *ControllerNetworkMember_VMajor) FromControllerNetworkMemberVMajor1(v ControllerNetworkMemberVMajor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeControllerNetworkMemberVMajor1 performs a merge with any union data inside the ControllerNetworkMember_VMajor, using the provided ControllerNetworkMemberVMajor1
func (t *ControllerNetworkMember_VMajor) MergeControllerNetworkMemberVMajor1(v ControllerNetworkMemberVMajor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMember_VMajor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMember_VMajor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the ControllerNetworkMember_VMinor as a VersionDigit
func (t ControllerNetworkMember_VMinor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the ControllerNetworkMember_VMinor as the provided VersionDigit
func (t *ControllerNetworkMember_VMinor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the ControllerNetworkMember_VMinor, using the provided VersionDigit
func (t *ControllerNetworkMember_VMinor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsControllerNetworkMemberVMinor1 returns the union data inside the ControllerNetworkMember_VMinor as a ControllerNetworkMemberVMinor1
func (t ControllerNetworkMember_VMinor) AsControllerNetworkMemberVMinor1() (ControllerNetworkMemberVMinor1, error) {
	var body ControllerNetworkMemberVMinor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromControllerNetworkMemberVMinor1 overwrites any union data inside the ControllerNetworkMember_VMinor as the provided ControllerNetworkMemberVMinor1
func (t *ControllerNetworkMember_VMinor) FromControllerNetworkMemberVMinor1(v ControllerNetworkMemberVMinor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeControllerNetworkMemberVMinor1 performs a merge with any union data inside the ControllerNetworkMember_VMinor, using the provided ControllerNetworkMemberVMinor1
func (t *ControllerNetworkMember_VMinor) MergeControllerNetworkMemberVMinor1(v ControllerNetworkMemberVMinor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMember_VMinor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMember_VMinor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the ControllerNetworkMember_VProto as a VersionDigit
func (t ControllerNetworkMember_VProto) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the ControllerNetworkMember_VProto as the provided VersionDigit
func (t *ControllerNetworkMember_VProto) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the ControllerNetworkMember_VProto, using the provided VersionDigit
func (t *ControllerNetworkMember_VProto) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsControllerNetworkMemberVProto1 returns the union data inside the ControllerNetworkMember_VProto as a ControllerNetworkMemberVProto1
func (t ControllerNetworkMember_VProto) AsControllerNetworkMemberVProto1() (ControllerNetworkMemberVProto1, error) {
	var body ControllerNetworkMemberVProto1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromControllerNetworkMemberVProto1 overwrites any union data inside the ControllerNetworkMember_VProto as the provided ControllerNetworkMemberVProto1
func (t *ControllerNetworkMember_VProto) FromControllerNetworkMemberVProto1(v ControllerNetworkMemberVProto1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeControllerNetworkMemberVProto1 performs a merge with any union data inside the ControllerNetworkMember_VProto, using the provided ControllerNetworkMemberVProto1
func (t *ControllerNetworkMember_VProto) MergeControllerNetworkMemberVProto1(v ControllerNetworkMemberVProto1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMember_VProto) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMember_VProto) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the ControllerNetworkMember_VRev as a VersionDigit
func (t ControllerNetworkMember_VRev) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the ControllerNetworkMember_VRev as the provided VersionDigit
func (t *ControllerNetworkMember_VRev) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the ControllerNetworkMember_VRev, using the provided VersionDigit
func (t *ControllerNetworkMember_VRev) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsControllerNetworkMemberVRev1 returns the union data inside the ControllerNetworkMember_VRev as a ControllerNetworkMemberVRev1
func (t ControllerNetworkMember_VRev) AsControllerNetworkMemberVRev1() (ControllerNetworkMemberVRev1, error) {
	var body ControllerNetworkMemberVRev1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromControllerNetworkMemberVRev1 overwrites any union data inside the ControllerNetworkMember_VRev as the provided ControllerNetworkMemberVRev1
func (t *ControllerNetworkMember_VRev) FromControllerNetworkMemberVRev1(v ControllerNetworkMemberVRev1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeControllerNetworkMemberVRev1 performs a merge with any union data inside the ControllerNetworkMember_VRev, using the provided ControllerNetworkMemberVRev1
func (t *ControllerNetworkMember_VRev) MergeControllerNetworkMemberVRev1(v ControllerNetworkMemberVRev1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMember_VRev) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMember_VRev) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkMemberRequest_IpAssignments_Item as a IPv4
func (t ControllerNetworkMemberRequest_IpAssignments_Item) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkMemberRequest_IpAssignments_Item as the provided IPv4
func (t *ControllerNetworkMemberRequest_IpAssignments_Item) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkMemberRequest_IpAssignments_Item, using the provided IPv4
func (t *ControllerNetworkMemberRequest_IpAssignments_Item) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkMemberRequest_IpAssignments_Item as a IPv6
func (t ControllerNetworkMemberRequest_IpAssignments_Item) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkMemberRequest_IpAssignments_Item as the provided IPv6
func (t *ControllerNetworkMemberRequest_IpAssignments_Item) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkMemberRequest_IpAssignments_Item, using the provided IPv6
func (t *ControllerNetworkMemberRequest_IpAssignments_Item) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkMemberRequest_IpAssignments_Item) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkMemberRequest_IpAssignments_Item) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsNetworkDNS returns the union data inside the ControllerNetworkRequest_Dns as a NetworkDNS
func (t ControllerNetworkRequest_Dns) AsNetworkDNS() (NetworkDNS, error) {
	var body NetworkDNS
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNetworkDNS overwrites any union data inside the ControllerNetworkRequest_Dns as the provided NetworkDNS
func (t *ControllerNetworkRequest_Dns) FromNetworkDNS(v NetworkDNS) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNetworkDNS performs a merge with any union data inside the ControllerNetworkRequest_Dns, using the provided NetworkDNS
func (t *ControllerNetworkRequest_Dns) MergeNetworkDNS(v NetworkDNS) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEmptyArrayItem returns the union data inside the ControllerNetworkRequest_Dns as a EmptyArrayItem
func (t ControllerNetworkRequest_Dns) AsEmptyArrayItem() (EmptyArrayItem, error) {
	var body EmptyArrayItem
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEmptyArrayItem overwrites any union data inside the ControllerNetworkRequest_Dns as the provided EmptyArrayItem
func (t *ControllerNetworkRequest_Dns) FromEmptyArrayItem(v EmptyArrayItem) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEmptyArrayItem performs a merge with any union data inside the ControllerNetworkRequest_Dns, using the provided EmptyArrayItem
func (t *ControllerNetworkRequest_Dns) MergeEmptyArrayItem(v EmptyArrayItem) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkRequest_Dns) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkRequest_Dns) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd as a IPv4
func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd as the provided IPv4
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd, using the provided IPv4
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd as a IPv6
func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd as the provided IPv6
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd, using the provided IPv6
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeEnd) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart as a IPv4
func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart as the provided IPv4
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart, using the provided IPv4
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart as a IPv6
func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart as the provided IPv6
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkRequest_IpAssignmentPools_IpRangeStart, using the provided IPv6
func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkRequest_IpAssignmentPools_IpRangeStart) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkRequest_Routes_Target as a IPv4
func (t ControllerNetworkRequest_Routes_Target) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkRequest_Routes_Target as the provided IPv4
func (t *ControllerNetworkRequest_Routes_Target) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkRequest_Routes_Target, using the provided IPv4
func (t *ControllerNetworkRequest_Routes_Target) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkRequest_Routes_Target as a IPv6
func (t ControllerNetworkRequest_Routes_Target) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkRequest_Routes_Target as the provided IPv6
func (t *ControllerNetworkRequest_Routes_Target) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkRequest_Routes_Target, using the provided IPv6
func (t *ControllerNetworkRequest_Routes_Target) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkRequest_Routes_Target) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkRequest_Routes_Target) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the ControllerNetworkRequest_Routes_Via as a IPv4
func (t ControllerNetworkRequest_Routes_Via) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the ControllerNetworkRequest_Routes_Via as the provided IPv4
func (t *ControllerNetworkRequest_Routes_Via) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the ControllerNetworkRequest_Routes_Via, using the provided IPv4
func (t *ControllerNetworkRequest_Routes_Via) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the ControllerNetworkRequest_Routes_Via as a IPv6
func (t ControllerNetworkRequest_Routes_Via) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the ControllerNetworkRequest_Routes_Via as the provided IPv6
func (t *ControllerNetworkRequest_Routes_Via) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the ControllerNetworkRequest_Routes_Via, using the provided IPv6
func (t *ControllerNetworkRequest_Routes_Via) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t ControllerNetworkRequest_Routes_Via) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *ControllerNetworkRequest_Routes_Via) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsDomain returns the union data inside the NetworkDNS_Domain as a Domain
func (t NetworkDNS_Domain) AsDomain() (Domain, error) {
	var body Domain
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromDomain overwrites any union data inside the NetworkDNS_Domain as the provided Domain
func (t *NetworkDNS_Domain) FromDomain(v Domain) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeDomain performs a merge with any union data inside the NetworkDNS_Domain, using the provided Domain
func (t *NetworkDNS_Domain) MergeDomain(v Domain) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsNetworkDNSDomain1 returns the union data inside the NetworkDNS_Domain as a NetworkDNSDomain1
func (t NetworkDNS_Domain) AsNetworkDNSDomain1() (NetworkDNSDomain1, error) {
	var body NetworkDNSDomain1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNetworkDNSDomain1 overwrites any union data inside the NetworkDNS_Domain as the provided NetworkDNSDomain1
func (t *NetworkDNS_Domain) FromNetworkDNSDomain1(v NetworkDNSDomain1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNetworkDNSDomain1 performs a merge with any union data inside the NetworkDNS_Domain, using the provided NetworkDNSDomain1
func (t *NetworkDNS_Domain) MergeNetworkDNSDomain1(v NetworkDNSDomain1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NetworkDNS_Domain) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NetworkDNS_Domain) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsIPv4 returns the union data inside the NetworkDNS_Servers_Item as a IPv4
func (t NetworkDNS_Servers_Item) AsIPv4() (IPv4, error) {
	var body IPv4
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv4 overwrites any union data inside the NetworkDNS_Servers_Item as the provided IPv4
func (t *NetworkDNS_Servers_Item) FromIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv4 performs a merge with any union data inside the NetworkDNS_Servers_Item, using the provided IPv4
func (t *NetworkDNS_Servers_Item) MergeIPv4(v IPv4) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsIPv6 returns the union data inside the NetworkDNS_Servers_Item as a IPv6
func (t NetworkDNS_Servers_Item) AsIPv6() (IPv6, error) {
	var body IPv6
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromIPv6 overwrites any union data inside the NetworkDNS_Servers_Item as the provided IPv6
func (t *NetworkDNS_Servers_Item) FromIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeIPv6 performs a merge with any union data inside the NetworkDNS_Servers_Item, using the provided IPv6
func (t *NetworkDNS_Servers_Item) MergeIPv6(v IPv6) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NetworkDNS_Servers_Item) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NetworkDNS_Servers_Item) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the NodeStatus_VersionBuild as a VersionDigit
func (t NodeStatus_VersionBuild) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the NodeStatus_VersionBuild as the provided VersionDigit
func (t *NodeStatus_VersionBuild) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the NodeStatus_VersionBuild, using the provided VersionDigit
func (t *NodeStatus_VersionBuild) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsNodeStatusVersionBuild1 returns the union data inside the NodeStatus_VersionBuild as a NodeStatusVersionBuild1
func (t NodeStatus_VersionBuild) AsNodeStatusVersionBuild1() (NodeStatusVersionBuild1, error) {
	var body NodeStatusVersionBuild1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNodeStatusVersionBuild1 overwrites any union data inside the NodeStatus_VersionBuild as the provided NodeStatusVersionBuild1
func (t *NodeStatus_VersionBuild) FromNodeStatusVersionBuild1(v NodeStatusVersionBuild1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNodeStatusVersionBuild1 performs a merge with any union data inside the NodeStatus_VersionBuild, using the provided NodeStatusVersionBuild1
func (t *NodeStatus_VersionBuild) MergeNodeStatusVersionBuild1(v NodeStatusVersionBuild1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NodeStatus_VersionBuild) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NodeStatus_VersionBuild) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the NodeStatus_VersionMajor as a VersionDigit
func (t NodeStatus_VersionMajor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the NodeStatus_VersionMajor as the provided VersionDigit
func (t *NodeStatus_VersionMajor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the NodeStatus_VersionMajor, using the provided VersionDigit
func (t *NodeStatus_VersionMajor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsNodeStatusVersionMajor1 returns the union data inside the NodeStatus_VersionMajor as a NodeStatusVersionMajor1
func (t NodeStatus_VersionMajor) AsNodeStatusVersionMajor1() (NodeStatusVersionMajor1, error) {
	var body NodeStatusVersionMajor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNodeStatusVersionMajor1 overwrites any union data inside the NodeStatus_VersionMajor as the provided NodeStatusVersionMajor1
func (t *NodeStatus_VersionMajor) FromNodeStatusVersionMajor1(v NodeStatusVersionMajor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNodeStatusVersionMajor1 performs a merge with any union data inside the NodeStatus_VersionMajor, using the provided NodeStatusVersionMajor1
func (t *NodeStatus_VersionMajor) MergeNodeStatusVersionMajor1(v NodeStatusVersionMajor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NodeStatus_VersionMajor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NodeStatus_VersionMajor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the NodeStatus_VersionMinor as a VersionDigit
func (t NodeStatus_VersionMinor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the NodeStatus_VersionMinor as the provided VersionDigit
func (t *NodeStatus_VersionMinor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the NodeStatus_VersionMinor, using the provided VersionDigit
func (t *NodeStatus_VersionMinor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsNodeStatusVersionMinor1 returns the union data inside the NodeStatus_VersionMinor as a NodeStatusVersionMinor1
func (t NodeStatus_VersionMinor) AsNodeStatusVersionMinor1() (NodeStatusVersionMinor1, error) {
	var body NodeStatusVersionMinor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNodeStatusVersionMinor1 overwrites any union data inside the NodeStatus_VersionMinor as the provided NodeStatusVersionMinor1
func (t *NodeStatus_VersionMinor) FromNodeStatusVersionMinor1(v NodeStatusVersionMinor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNodeStatusVersionMinor1 performs a merge with any union data inside the NodeStatus_VersionMinor, using the provided NodeStatusVersionMinor1
func (t *NodeStatus_VersionMinor) MergeNodeStatusVersionMinor1(v NodeStatusVersionMinor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NodeStatus_VersionMinor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NodeStatus_VersionMinor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the NodeStatus_VersionRev as a VersionDigit
func (t NodeStatus_VersionRev) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the NodeStatus_VersionRev as the provided VersionDigit
func (t *NodeStatus_VersionRev) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the NodeStatus_VersionRev, using the provided VersionDigit
func (t *NodeStatus_VersionRev) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsNodeStatusVersionRev1 returns the union data inside the NodeStatus_VersionRev as a NodeStatusVersionRev1
func (t NodeStatus_VersionRev) AsNodeStatusVersionRev1() (NodeStatusVersionRev1, error) {
	var body NodeStatusVersionRev1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromNodeStatusVersionRev1 overwrites any union data inside the NodeStatus_VersionRev as the provided NodeStatusVersionRev1
func (t *NodeStatus_VersionRev) FromNodeStatusVersionRev1(v NodeStatusVersionRev1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeNodeStatusVersionRev1 performs a merge with any union data inside the NodeStatus_VersionRev, using the provided NodeStatusVersionRev1
func (t *NodeStatus_VersionRev) MergeNodeStatusVersionRev1(v NodeStatusVersionRev1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t NodeStatus_VersionRev) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *NodeStatus_VersionRev) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsUSafeint returns the union data inside the Peer_Latency as a USafeint
func (t Peer_Latency) AsUSafeint() (USafeint, error) {
	var body USafeint
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromUSafeint overwrites any union data inside the Peer_Latency as the provided USafeint
func (t *Peer_Latency) FromUSafeint(v USafeint) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeUSafeint performs a merge with any union data inside the Peer_Latency, using the provided USafeint
func (t *Peer_Latency) MergeUSafeint(v USafeint) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsPeerLatency1 returns the union data inside the Peer_Latency as a PeerLatency1
func (t Peer_Latency) AsPeerLatency1() (PeerLatency1, error) {
	var body PeerLatency1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromPeerLatency1 overwrites any union data inside the Peer_Latency as the provided PeerLatency1
func (t *Peer_Latency) FromPeerLatency1(v PeerLatency1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergePeerLatency1 performs a merge with any union data inside the Peer_Latency, using the provided PeerLatency1
func (t *Peer_Latency) MergePeerLatency1(v PeerLatency1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t Peer_Latency) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *Peer_Latency) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the Peer_VersionMajor as a VersionDigit
func (t Peer_VersionMajor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the Peer_VersionMajor as the provided VersionDigit
func (t *Peer_VersionMajor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the Peer_VersionMajor, using the provided VersionDigit
func (t *Peer_VersionMajor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsPeerVersionMajor1 returns the union data inside the Peer_VersionMajor as a PeerVersionMajor1
func (t Peer_VersionMajor) AsPeerVersionMajor1() (PeerVersionMajor1, error) {
	var body PeerVersionMajor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromPeerVersionMajor1 overwrites any union data inside the Peer_VersionMajor as the provided PeerVersionMajor1
func (t *Peer_VersionMajor) FromPeerVersionMajor1(v PeerVersionMajor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergePeerVersionMajor1 performs a merge with any union data inside the Peer_VersionMajor, using the provided PeerVersionMajor1
func (t *Peer_VersionMajor) MergePeerVersionMajor1(v PeerVersionMajor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t Peer_VersionMajor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *Peer_VersionMajor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the Peer_VersionMinor as a VersionDigit
func (t Peer_VersionMinor) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the Peer_VersionMinor as the provided VersionDigit
func (t *Peer_VersionMinor) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the Peer_VersionMinor, using the provided VersionDigit
func (t *Peer_VersionMinor) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsPeerVersionMinor1 returns the union data inside the Peer_VersionMinor as a PeerVersionMinor1
func (t Peer_VersionMinor) AsPeerVersionMinor1() (PeerVersionMinor1, error) {
	var body PeerVersionMinor1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromPeerVersionMinor1 overwrites any union data inside the Peer_VersionMinor as the provided PeerVersionMinor1
func (t *Peer_VersionMinor) FromPeerVersionMinor1(v PeerVersionMinor1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergePeerVersionMinor1 performs a merge with any union data inside the Peer_VersionMinor, using the provided PeerVersionMinor1
func (t *Peer_VersionMinor) MergePeerVersionMinor1(v PeerVersionMinor1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t Peer_VersionMinor) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *Peer_VersionMinor) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsVersionDigit returns the union data inside the Peer_VersionRev as a VersionDigit
func (t Peer_VersionRev) AsVersionDigit() (VersionDigit, error) {
	var body VersionDigit
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromVersionDigit overwrites any union data inside the Peer_VersionRev as the provided VersionDigit
func (t *Peer_VersionRev) FromVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeVersionDigit performs a merge with any union data inside the Peer_VersionRev, using the provided VersionDigit
func (t *Peer_VersionRev) MergeVersionDigit(v VersionDigit) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsPeerVersionRev1 returns the union data inside the Peer_VersionRev as a PeerVersionRev1
func (t Peer_VersionRev) AsPeerVersionRev1() (PeerVersionRev1, error) {
	var body PeerVersionRev1
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromPeerVersionRev1 overwrites any union data inside the Peer_VersionRev as the provided PeerVersionRev1
func (t *Peer_VersionRev) FromPeerVersionRev1(v PeerVersionRev1) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergePeerVersionRev1 performs a merge with any union data inside the Peer_VersionRev, using the provided PeerVersionRev1
func (t *Peer_VersionRev) MergePeerVersionRev1(v PeerVersionRev1) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t Peer_VersionRev) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *Peer_VersionRev) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// ControllerReadControllerStatus request
	ControllerReadControllerStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkReadNetworks request
	NetworkReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RandomNetworkRandomNetworkWithBody request with any body
	RandomNetworkRandomNetworkWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	RandomNetworkRandomNetwork(ctx context.Context, body RandomNetworkRandomNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkDeleteNetwork request
	NetworkDeleteNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkReadNetwork request
	NetworkReadNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkPostNetworkWithBody request with any body
	NetworkPostNetworkWithBody(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	NetworkPostNetwork(ctx context.Context, networkId ZTNetworkID, body NetworkPostNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMembersListNetworkMembers request
	NetworkMembersListNetworkMembers(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMemberDelNetworkMember request
	NetworkMemberDelNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMemberGetNetworkMember request
	NetworkMemberGetNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMemberPostNetworkMemberWithBody request with any body
	NetworkMemberPostNetworkMemberWithBody(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	NetworkMemberPostNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, body NetworkMemberPostNetworkMemberJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMembershipReadNetworks request
	NetworkMembershipReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMembershipDelNetwork request
	NetworkMembershipDelNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMembershipGetNetwork request
	NetworkMembershipGetNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkMembershipSetNetworkWithBody request with any body
	NetworkMembershipSetNetworkWithBody(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	NetworkMembershipSetNetwork(ctx context.Context, networkId ZTNetworkID, body NetworkMembershipSetNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NodePeerReadNetworks request
	NodePeerReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NodePeerGetNetwork request
	NodePeerGetNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NodeStatusReadStatus request
	NodeStatusReadStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// NetworkReadNetworks2 request
	NetworkReadNetworks2(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// MemberListNetworkMembers2 request
	MemberListNetworkMembers2(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) ControllerReadControllerStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewControllerReadControllerStatusRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkReadNetworksRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) RandomNetworkRandomNetworkWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRandomNetworkRandomNetworkRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) RandomNetworkRandomNetwork(ctx context.Context, body RandomNetworkRandomNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRandomNetworkRandomNetworkRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkDeleteNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkDeleteNetworkRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkReadNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkReadNetworkRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkPostNetworkWithBody(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkPostNetworkRequestWithBody(c.Server, networkId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkPostNetwork(ctx context.Context, networkId ZTNetworkID, body NetworkPostNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkPostNetworkRequest(c.Server, networkId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembersListNetworkMembers(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembersListNetworkMembersRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMemberDelNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMemberDelNetworkMemberRequest(c.Server, networkId, nodeId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMemberGetNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMemberGetNetworkMemberRequest(c.Server, networkId, nodeId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMemberPostNetworkMemberWithBody(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMemberPostNetworkMemberRequestWithBody(c.Server, networkId, nodeId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMemberPostNetworkMember(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, body NetworkMemberPostNetworkMemberJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMemberPostNetworkMemberRequest(c.Server, networkId, nodeId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembershipReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembershipReadNetworksRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembershipDelNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembershipDelNetworkRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembershipGetNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembershipGetNetworkRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembershipSetNetworkWithBody(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembershipSetNetworkRequestWithBody(c.Server, networkId, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkMembershipSetNetwork(ctx context.Context, networkId ZTNetworkID, body NetworkMembershipSetNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkMembershipSetNetworkRequest(c.Server, networkId, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NodePeerReadNetworks(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNodePeerReadNetworksRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NodePeerGetNetwork(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNodePeerGetNetworkRequest(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NodeStatusReadStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNodeStatusReadStatusRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) NetworkReadNetworks2(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewNetworkReadNetworks2Request(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) MemberListNetworkMembers2(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMemberListNetworkMembers2Request(c.Server, networkId)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewControllerReadControllerStatusRequest generates requests for ControllerReadControllerStatus
func NewControllerReadControllerStatusRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkReadNetworksRequest generates requests for NetworkReadNetworks
func NewNetworkReadNetworksRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewRandomNetworkRandomNetworkRequest calls the generic RandomNetworkRandomNetwork builder with application/json body
func NewRandomNetworkRandomNetworkRequest(server string, body RandomNetworkRandomNetworkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewRandomNetworkRandomNetworkRequestWithBody(server, "application/json", bodyReader)
}

// NewRandomNetworkRandomNetworkRequestWithBody generates requests for RandomNetworkRandomNetwork with any type of body
func NewRandomNetworkRandomNetworkRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewNetworkDeleteNetworkRequest generates requests for NetworkDeleteNetwork
func NewNetworkDeleteNetworkRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkReadNetworkRequest generates requests for NetworkReadNetwork
func NewNetworkReadNetworkRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkPostNetworkRequest calls the generic NetworkPostNetwork builder with application/json body
func NewNetworkPostNetworkRequest(server string, networkId ZTNetworkID, body NetworkPostNetworkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewNetworkPostNetworkRequestWithBody(server, networkId, "application/json", bodyReader)
}

// NewNetworkPostNetworkRequestWithBody generates requests for NetworkPostNetwork with any type of body
func NewNetworkPostNetworkRequestWithBody(server string, networkId ZTNetworkID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewNetworkMembersListNetworkMembersRequest generates requests for NetworkMembersListNetworkMembers
func NewNetworkMembersListNetworkMembersRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s/member", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMemberDelNetworkMemberRequest generates requests for NetworkMemberDelNetworkMember
func NewNetworkMemberDelNetworkMemberRequest(server string, networkId ZTNetworkID, nodeId ZTAddress) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "node_id", runtime.ParamLocationPath, nodeId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s/member/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMemberGetNetworkMemberRequest generates requests for NetworkMemberGetNetworkMember
func NewNetworkMemberGetNetworkMemberRequest(server string, networkId ZTNetworkID, nodeId ZTAddress) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "node_id", runtime.ParamLocationPath, nodeId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s/member/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMemberPostNetworkMemberRequest calls the generic NetworkMemberPostNetworkMember builder with application/json body
func NewNetworkMemberPostNetworkMemberRequest(server string, networkId ZTNetworkID, nodeId ZTAddress, body NetworkMemberPostNetworkMemberJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewNetworkMemberPostNetworkMemberRequestWithBody(server, networkId, nodeId, "application/json", bodyReader)
}

// NewNetworkMemberPostNetworkMemberRequestWithBody generates requests for NetworkMemberPostNetworkMember with any type of body
func NewNetworkMemberPostNetworkMemberRequestWithBody(server string, networkId ZTNetworkID, nodeId ZTAddress, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "node_id", runtime.ParamLocationPath, nodeId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/controller/network/%s/member/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewNetworkMembershipReadNetworksRequest generates requests for NetworkMembershipReadNetworks
func NewNetworkMembershipReadNetworksRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/network")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMembershipDelNetworkRequest generates requests for NetworkMembershipDelNetwork
func NewNetworkMembershipDelNetworkRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMembershipGetNetworkRequest generates requests for NetworkMembershipGetNetwork
func NewNetworkMembershipGetNetworkRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkMembershipSetNetworkRequest calls the generic NetworkMembershipSetNetwork builder with application/json body
func NewNetworkMembershipSetNetworkRequest(server string, networkId ZTNetworkID, body NetworkMembershipSetNetworkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewNetworkMembershipSetNetworkRequestWithBody(server, networkId, "application/json", bodyReader)
}

// NewNetworkMembershipSetNetworkRequestWithBody generates requests for NetworkMembershipSetNetwork with any type of body
func NewNetworkMembershipSetNetworkRequestWithBody(server string, networkId ZTNetworkID, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/network/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewNodePeerReadNetworksRequest generates requests for NodePeerReadNetworks
func NewNodePeerReadNetworksRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/peer")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNodePeerGetNetworkRequest generates requests for NodePeerGetNetwork
func NewNodePeerGetNetworkRequest(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/peer/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNodeStatusReadStatusRequest generates requests for NodeStatusReadStatus
func NewNodeStatusReadStatusRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/status")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewNetworkReadNetworks2Request generates requests for NetworkReadNetworks2
func NewNetworkReadNetworks2Request(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/unstable/controller/network")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMemberListNetworkMembers2Request generates requests for MemberListNetworkMembers2
func NewMemberListNetworkMembers2Request(server string, networkId ZTNetworkID) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "network_id", runtime.ParamLocationPath, networkId)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/unstable/controller/network/%s/member", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// ControllerReadControllerStatusWithResponse request
	ControllerReadControllerStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControllerReadControllerStatusResponse, error)

	// NetworkReadNetworksWithResponse request
	NetworkReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkReadNetworksResponse, error)

	// RandomNetworkRandomNetworkWithBodyWithResponse request with any body
	RandomNetworkRandomNetworkWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RandomNetworkRandomNetworkResponse, error)

	RandomNetworkRandomNetworkWithResponse(ctx context.Context, body RandomNetworkRandomNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*RandomNetworkRandomNetworkResponse, error)

	// NetworkDeleteNetworkWithResponse request
	NetworkDeleteNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkDeleteNetworkResponse, error)

	// NetworkReadNetworkWithResponse request
	NetworkReadNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkReadNetworkResponse, error)

	// NetworkPostNetworkWithBodyWithResponse request with any body
	NetworkPostNetworkWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkPostNetworkResponse, error)

	NetworkPostNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, body NetworkPostNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkPostNetworkResponse, error)

	// NetworkMembersListNetworkMembersWithResponse request
	NetworkMembersListNetworkMembersWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembersListNetworkMembersResponse, error)

	// NetworkMemberDelNetworkMemberWithResponse request
	NetworkMemberDelNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*NetworkMemberDelNetworkMemberResponse, error)

	// NetworkMemberGetNetworkMemberWithResponse request
	NetworkMemberGetNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*NetworkMemberGetNetworkMemberResponse, error)

	// NetworkMemberPostNetworkMemberWithBodyWithResponse request with any body
	NetworkMemberPostNetworkMemberWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkMemberPostNetworkMemberResponse, error)

	NetworkMemberPostNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, body NetworkMemberPostNetworkMemberJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkMemberPostNetworkMemberResponse, error)

	// NetworkMembershipReadNetworksWithResponse request
	NetworkMembershipReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkMembershipReadNetworksResponse, error)

	// NetworkMembershipDelNetworkWithResponse request
	NetworkMembershipDelNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembershipDelNetworkResponse, error)

	// NetworkMembershipGetNetworkWithResponse request
	NetworkMembershipGetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembershipGetNetworkResponse, error)

	// NetworkMembershipSetNetworkWithBodyWithResponse request with any body
	NetworkMembershipSetNetworkWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkMembershipSetNetworkResponse, error)

	NetworkMembershipSetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, body NetworkMembershipSetNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkMembershipSetNetworkResponse, error)

	// NodePeerReadNetworksWithResponse request
	NodePeerReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NodePeerReadNetworksResponse, error)

	// NodePeerGetNetworkWithResponse request
	NodePeerGetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NodePeerGetNetworkResponse, error)

	// NodeStatusReadStatusWithResponse request
	NodeStatusReadStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NodeStatusReadStatusResponse, error)

	// NetworkReadNetworks2WithResponse request
	NetworkReadNetworks2WithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkReadNetworks2Response, error)

	// MemberListNetworkMembers2WithResponse request
	MemberListNetworkMembers2WithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*MemberListNetworkMembers2Response, error)
}

type ControllerReadControllerStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerStatus
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r ControllerReadControllerStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ControllerReadControllerStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkReadNetworksResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkIDList
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkReadNetworksResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkReadNetworksResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type RandomNetworkRandomNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r RandomNetworkRandomNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r RandomNetworkRandomNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkDeleteNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkDeleteNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkDeleteNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkReadNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkReadNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkReadNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkPostNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkPostNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkPostNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMembersListNetworkMembersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkMemberList
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMembersListNetworkMembersResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMembersListNetworkMembersResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMemberDelNetworkMemberResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkMember
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMemberDelNetworkMemberResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMemberDelNetworkMemberResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMemberGetNetworkMemberResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkMember
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMemberGetNetworkMemberResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMemberGetNetworkMemberResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMemberPostNetworkMemberResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkMember
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMemberPostNetworkMemberResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMemberPostNetworkMemberResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMembershipReadNetworksResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]JoinedNetwork
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMembershipReadNetworksResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMembershipReadNetworksResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMembershipDelNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LeaveResult
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMembershipDelNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMembershipDelNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMembershipGetNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *JoinedNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMembershipGetNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMembershipGetNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkMembershipSetNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *JoinedNetwork
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkMembershipSetNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkMembershipSetNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NodePeerReadNetworksResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Peer
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NodePeerReadNetworksResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NodePeerReadNetworksResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NodePeerGetNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Peer
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NodePeerGetNetworkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NodePeerGetNetworkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NodeStatusReadStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *NodeStatus
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NodeStatusReadStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NodeStatusReadStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type NetworkReadNetworks2Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworks
	JSON401      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r NetworkReadNetworks2Response) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r NetworkReadNetworks2Response) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type MemberListNetworkMembers2Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ControllerNetworkMemberListFull
	JSON401      *map[string]interface{}
	JSON404      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r MemberListNetworkMembers2Response) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r MemberListNetworkMembers2Response) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// ControllerReadControllerStatusWithResponse request returning *ControllerReadControllerStatusResponse
func (c *ClientWithResponses) ControllerReadControllerStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ControllerReadControllerStatusResponse, error) {
	rsp, err := c.ControllerReadControllerStatus(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseControllerReadControllerStatusResponse(rsp)
}

// NetworkReadNetworksWithResponse request returning *NetworkReadNetworksResponse
func (c *ClientWithResponses) NetworkReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkReadNetworksResponse, error) {
	rsp, err := c.NetworkReadNetworks(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkReadNetworksResponse(rsp)
}

// RandomNetworkRandomNetworkWithBodyWithResponse request with arbitrary body returning *RandomNetworkRandomNetworkResponse
func (c *ClientWithResponses) RandomNetworkRandomNetworkWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RandomNetworkRandomNetworkResponse, error) {
	rsp, err := c.RandomNetworkRandomNetworkWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRandomNetworkRandomNetworkResponse(rsp)
}

func (c *ClientWithResponses) RandomNetworkRandomNetworkWithResponse(ctx context.Context, body RandomNetworkRandomNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*RandomNetworkRandomNetworkResponse, error) {
	rsp, err := c.RandomNetworkRandomNetwork(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRandomNetworkRandomNetworkResponse(rsp)
}

// NetworkDeleteNetworkWithResponse request returning *NetworkDeleteNetworkResponse
func (c *ClientWithResponses) NetworkDeleteNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkDeleteNetworkResponse, error) {
	rsp, err := c.NetworkDeleteNetwork(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkDeleteNetworkResponse(rsp)
}

// NetworkReadNetworkWithResponse request returning *NetworkReadNetworkResponse
func (c *ClientWithResponses) NetworkReadNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkReadNetworkResponse, error) {
	rsp, err := c.NetworkReadNetwork(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkReadNetworkResponse(rsp)
}

// NetworkPostNetworkWithBodyWithResponse request with arbitrary body returning *NetworkPostNetworkResponse
func (c *ClientWithResponses) NetworkPostNetworkWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkPostNetworkResponse, error) {
	rsp, err := c.NetworkPostNetworkWithBody(ctx, networkId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkPostNetworkResponse(rsp)
}

func (c *ClientWithResponses) NetworkPostNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, body NetworkPostNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkPostNetworkResponse, error) {
	rsp, err := c.NetworkPostNetwork(ctx, networkId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkPostNetworkResponse(rsp)
}

// NetworkMembersListNetworkMembersWithResponse request returning *NetworkMembersListNetworkMembersResponse
func (c *ClientWithResponses) NetworkMembersListNetworkMembersWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembersListNetworkMembersResponse, error) {
	rsp, err := c.NetworkMembersListNetworkMembers(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembersListNetworkMembersResponse(rsp)
}

// NetworkMemberDelNetworkMemberWithResponse request returning *NetworkMemberDelNetworkMemberResponse
func (c *ClientWithResponses) NetworkMemberDelNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*NetworkMemberDelNetworkMemberResponse, error) {
	rsp, err := c.NetworkMemberDelNetworkMember(ctx, networkId, nodeId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMemberDelNetworkMemberResponse(rsp)
}

// NetworkMemberGetNetworkMemberWithResponse request returning *NetworkMemberGetNetworkMemberResponse
func (c *ClientWithResponses) NetworkMemberGetNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, reqEditors ...RequestEditorFn) (*NetworkMemberGetNetworkMemberResponse, error) {
	rsp, err := c.NetworkMemberGetNetworkMember(ctx, networkId, nodeId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMemberGetNetworkMemberResponse(rsp)
}

// NetworkMemberPostNetworkMemberWithBodyWithResponse request with arbitrary body returning *NetworkMemberPostNetworkMemberResponse
func (c *ClientWithResponses) NetworkMemberPostNetworkMemberWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkMemberPostNetworkMemberResponse, error) {
	rsp, err := c.NetworkMemberPostNetworkMemberWithBody(ctx, networkId, nodeId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMemberPostNetworkMemberResponse(rsp)
}

func (c *ClientWithResponses) NetworkMemberPostNetworkMemberWithResponse(ctx context.Context, networkId ZTNetworkID, nodeId ZTAddress, body NetworkMemberPostNetworkMemberJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkMemberPostNetworkMemberResponse, error) {
	rsp, err := c.NetworkMemberPostNetworkMember(ctx, networkId, nodeId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMemberPostNetworkMemberResponse(rsp)
}

// NetworkMembershipReadNetworksWithResponse request returning *NetworkMembershipReadNetworksResponse
func (c *ClientWithResponses) NetworkMembershipReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkMembershipReadNetworksResponse, error) {
	rsp, err := c.NetworkMembershipReadNetworks(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembershipReadNetworksResponse(rsp)
}

// NetworkMembershipDelNetworkWithResponse request returning *NetworkMembershipDelNetworkResponse
func (c *ClientWithResponses) NetworkMembershipDelNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembershipDelNetworkResponse, error) {
	rsp, err := c.NetworkMembershipDelNetwork(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembershipDelNetworkResponse(rsp)
}

// NetworkMembershipGetNetworkWithResponse request returning *NetworkMembershipGetNetworkResponse
func (c *ClientWithResponses) NetworkMembershipGetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NetworkMembershipGetNetworkResponse, error) {
	rsp, err := c.NetworkMembershipGetNetwork(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembershipGetNetworkResponse(rsp)
}

// NetworkMembershipSetNetworkWithBodyWithResponse request with arbitrary body returning *NetworkMembershipSetNetworkResponse
func (c *ClientWithResponses) NetworkMembershipSetNetworkWithBodyWithResponse(ctx context.Context, networkId ZTNetworkID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*NetworkMembershipSetNetworkResponse, error) {
	rsp, err := c.NetworkMembershipSetNetworkWithBody(ctx, networkId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembershipSetNetworkResponse(rsp)
}

func (c *ClientWithResponses) NetworkMembershipSetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, body NetworkMembershipSetNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*NetworkMembershipSetNetworkResponse, error) {
	rsp, err := c.NetworkMembershipSetNetwork(ctx, networkId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkMembershipSetNetworkResponse(rsp)
}

// NodePeerReadNetworksWithResponse request returning *NodePeerReadNetworksResponse
func (c *ClientWithResponses) NodePeerReadNetworksWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NodePeerReadNetworksResponse, error) {
	rsp, err := c.NodePeerReadNetworks(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNodePeerReadNetworksResponse(rsp)
}

// NodePeerGetNetworkWithResponse request returning *NodePeerGetNetworkResponse
func (c *ClientWithResponses) NodePeerGetNetworkWithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*NodePeerGetNetworkResponse, error) {
	rsp, err := c.NodePeerGetNetwork(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNodePeerGetNetworkResponse(rsp)
}

// NodeStatusReadStatusWithResponse request returning *NodeStatusReadStatusResponse
func (c *ClientWithResponses) NodeStatusReadStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NodeStatusReadStatusResponse, error) {
	rsp, err := c.NodeStatusReadStatus(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNodeStatusReadStatusResponse(rsp)
}

// NetworkReadNetworks2WithResponse request returning *NetworkReadNetworks2Response
func (c *ClientWithResponses) NetworkReadNetworks2WithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*NetworkReadNetworks2Response, error) {
	rsp, err := c.NetworkReadNetworks2(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseNetworkReadNetworks2Response(rsp)
}

// MemberListNetworkMembers2WithResponse request returning *MemberListNetworkMembers2Response
func (c *ClientWithResponses) MemberListNetworkMembers2WithResponse(ctx context.Context, networkId ZTNetworkID, reqEditors ...RequestEditorFn) (*MemberListNetworkMembers2Response, error) {
	rsp, err := c.MemberListNetworkMembers2(ctx, networkId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMemberListNetworkMembers2Response(rsp)
}

// ParseControllerReadControllerStatusResponse parses an HTTP response from a ControllerReadControllerStatusWithResponse call
func ParseControllerReadControllerStatusResponse(rsp *http.Response) (*ControllerReadControllerStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ControllerReadControllerStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseNetworkReadNetworksResponse parses an HTTP response from a NetworkReadNetworksWithResponse call
func ParseNetworkReadNetworksResponse(rsp *http.Response) (*NetworkReadNetworksResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkReadNetworksResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkIDList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseRandomNetworkRandomNetworkResponse parses an HTTP response from a RandomNetworkRandomNetworkWithResponse call
func ParseRandomNetworkRandomNetworkResponse(rsp *http.Response) (*RandomNetworkRandomNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &RandomNetworkRandomNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkDeleteNetworkResponse parses an HTTP response from a NetworkDeleteNetworkWithResponse call
func ParseNetworkDeleteNetworkResponse(rsp *http.Response) (*NetworkDeleteNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkDeleteNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkReadNetworkResponse parses an HTTP response from a NetworkReadNetworkWithResponse call
func ParseNetworkReadNetworkResponse(rsp *http.Response) (*NetworkReadNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkReadNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkPostNetworkResponse parses an HTTP response from a NetworkPostNetworkWithResponse call
func ParseNetworkPostNetworkResponse(rsp *http.Response) (*NetworkPostNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkPostNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMembersListNetworkMembersResponse parses an HTTP response from a NetworkMembersListNetworkMembersWithResponse call
func ParseNetworkMembersListNetworkMembersResponse(rsp *http.Response) (*NetworkMembersListNetworkMembersResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMembersListNetworkMembersResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkMemberList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMemberDelNetworkMemberResponse parses an HTTP response from a NetworkMemberDelNetworkMemberWithResponse call
func ParseNetworkMemberDelNetworkMemberResponse(rsp *http.Response) (*NetworkMemberDelNetworkMemberResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMemberDelNetworkMemberResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkMember
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMemberGetNetworkMemberResponse parses an HTTP response from a NetworkMemberGetNetworkMemberWithResponse call
func ParseNetworkMemberGetNetworkMemberResponse(rsp *http.Response) (*NetworkMemberGetNetworkMemberResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMemberGetNetworkMemberResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkMember
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMemberPostNetworkMemberResponse parses an HTTP response from a NetworkMemberPostNetworkMemberWithResponse call
func ParseNetworkMemberPostNetworkMemberResponse(rsp *http.Response) (*NetworkMemberPostNetworkMemberResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMemberPostNetworkMemberResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkMember
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMembershipReadNetworksResponse parses an HTTP response from a NetworkMembershipReadNetworksWithResponse call
func ParseNetworkMembershipReadNetworksResponse(rsp *http.Response) (*NetworkMembershipReadNetworksResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMembershipReadNetworksResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []JoinedNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseNetworkMembershipDelNetworkResponse parses an HTTP response from a NetworkMembershipDelNetworkWithResponse call
func ParseNetworkMembershipDelNetworkResponse(rsp *http.Response) (*NetworkMembershipDelNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMembershipDelNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest LeaveResult
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMembershipGetNetworkResponse parses an HTTP response from a NetworkMembershipGetNetworkWithResponse call
func ParseNetworkMembershipGetNetworkResponse(rsp *http.Response) (*NetworkMembershipGetNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMembershipGetNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest JoinedNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNetworkMembershipSetNetworkResponse parses an HTTP response from a NetworkMembershipSetNetworkWithResponse call
func ParseNetworkMembershipSetNetworkResponse(rsp *http.Response) (*NetworkMembershipSetNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkMembershipSetNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest JoinedNetwork
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNodePeerReadNetworksResponse parses an HTTP response from a NodePeerReadNetworksWithResponse call
func ParseNodePeerReadNetworksResponse(rsp *http.Response) (*NodePeerReadNetworksResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NodePeerReadNetworksResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Peer
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseNodePeerGetNetworkResponse parses an HTTP response from a NodePeerGetNetworkWithResponse call
func ParseNodePeerGetNetworkResponse(rsp *http.Response) (*NodePeerGetNetworkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NodePeerGetNetworkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Peer
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseNodeStatusReadStatusResponse parses an HTTP response from a NodeStatusReadStatusWithResponse call
func ParseNodeStatusReadStatusResponse(rsp *http.Response) (*NodeStatusReadStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NodeStatusReadStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest NodeStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseNetworkReadNetworks2Response parses an HTTP response from a NetworkReadNetworks2WithResponse call
func ParseNetworkReadNetworks2Response(rsp *http.Response) (*NetworkReadNetworks2Response, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &NetworkReadNetworks2Response{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworks
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	}

	return response, nil
}

// ParseMemberListNetworkMembers2Response parses an HTTP response from a MemberListNetworkMembers2WithResponse call
func ParseMemberListNetworkMembers2Response(rsp *http.Response) (*MemberListNetworkMembers2Response, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &MemberListNetworkMembers2Response{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ControllerNetworkMemberListFull
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON401 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}