terraform-provider-binarylane/internal/binarylane/client_gen.go

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

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

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

// 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 {
	// GetAccount request
	GetAccount(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAccountKeys request
	GetAccountKeys(ctx context.Context, params *GetAccountKeysParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostAccountKeys(ctx context.Context, body PostAccountKeysJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAccountKeysKeyId request
	DeleteAccountKeysKeyId(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAccountKeysKeyId request
	GetAccountKeysKeyId(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PutAccountKeysKeyId(ctx context.Context, keyId int, body PutAccountKeysKeyIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetActions request
	GetActions(ctx context.Context, params *GetActionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetActionsActionId request
	GetActionsActionId(ctx context.Context, actionId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostActionsActionIdProceed(ctx context.Context, actionId int64, body PostActionsActionIdProceedJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// GetCustomersMyInvoices request
	GetCustomersMyInvoices(ctx context.Context, params *GetCustomersMyInvoicesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetCustomersMyInvoicesInvoiceId request
	GetCustomersMyInvoicesInvoiceId(ctx context.Context, invoiceId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// GetDataUsagesCurrent request
	GetDataUsagesCurrent(ctx context.Context, params *GetDataUsagesCurrentParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDataUsagesServerIdCurrent request
	GetDataUsagesServerIdCurrent(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDomains request
	GetDomains(ctx context.Context, params *GetDomainsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostDomains(ctx context.Context, body PostDomainsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	PostDomainsRefreshNameserverCache(ctx context.Context, body PostDomainsRefreshNameserverCacheJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDomainsDomainName request
	DeleteDomainsDomainName(ctx context.Context, domainName struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDomainsDomainName request
	GetDomainsDomainName(ctx context.Context, domainName struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDomainsDomainNameRecords request
	GetDomainsDomainNameRecords(ctx context.Context, domainName struct {
		union json.RawMessage
	}, params *GetDomainsDomainNameRecordsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostDomainsDomainNameRecordsWithBody request with any body
	PostDomainsDomainNameRecordsWithBody(ctx context.Context, domainName struct {
		union json.RawMessage
	}, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostDomainsDomainNameRecords(ctx context.Context, domainName struct {
		union json.RawMessage
	}, body PostDomainsDomainNameRecordsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteDomainsDomainNameRecordsRecordId request
	DeleteDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDomainsDomainNameRecordsRecordId request
	GetDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PutDomainsDomainNameRecordsRecordIdWithBody request with any body
	PutDomainsDomainNameRecordsRecordIdWithBody(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PutDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, body PutDomainsDomainNameRecordsRecordIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetImages request
	GetImages(ctx context.Context, params *GetImagesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetImagesImageIdOrSlug request
	GetImagesImageIdOrSlug(ctx context.Context, imageIdOrSlug struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetImagesImageIdDownload request
	GetImagesImageIdDownload(ctx context.Context, imageId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetLoadBalancers request
	GetLoadBalancers(ctx context.Context, params *GetLoadBalancersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostLoadBalancers(ctx context.Context, body PostLoadBalancersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// DeleteLoadBalancersLoadBalancerId request
	DeleteLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetLoadBalancersLoadBalancerId request
	GetLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PutLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, body PutLoadBalancersLoadBalancerIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	DeleteLoadBalancersLoadBalancerIdForwardingRules(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostLoadBalancersLoadBalancerIdForwardingRules(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	DeleteLoadBalancersLoadBalancerIdServers(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostLoadBalancersLoadBalancerIdServers(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetRegions request
	GetRegions(ctx context.Context, params *GetRegionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetReverseNamesIpv6 request
	GetReverseNamesIpv6(ctx context.Context, params *GetReverseNamesIpv6Params, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostReverseNamesIpv6(ctx context.Context, body PostReverseNamesIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSamplesetsServerId request
	GetSamplesetsServerId(ctx context.Context, serverId int64, params *GetSamplesetsServerIdParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSamplesetsServerIdLatest request
	GetSamplesetsServerIdLatest(ctx context.Context, serverId int64, params *GetSamplesetsServerIdLatestParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServers request
	GetServers(ctx context.Context, params *GetServersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServers(ctx context.Context, body PostServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	// DeleteServersServerId request
	DeleteServersServerId(ctx context.Context, serverId int64, params *DeleteServersServerIdParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerId request
	GetServersServerId(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdActions request
	GetServersServerIdActions(ctx context.Context, serverId int64, params *GetServersServerIdActionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActions(ctx context.Context, serverId int64, body PostServersServerIdActionsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsAddDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsAddDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsAttachBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsAttachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeAdvancedFeatures(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFeaturesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeAdvancedFirewallRules(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFirewallRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeBackupSchedule(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeBackupScheduleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeIpv6(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeIpv6ReverseNameservers(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6ReverseNameserversJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeKernel(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeKernelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeManageOffsiteBackupCopies(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeManageOffsiteBackupCopiesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeNetwork(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeOffsiteBackupLocation(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeOffsiteBackupLocationJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangePartner(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePartnerJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangePortBlocking(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePortBlockingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeRegion(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeRegionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeReverseName(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeReverseNameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeSeparatePrivateNetworkInterface(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeSourceAndDestinationCheck(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSourceAndDestinationCheckJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeThresholdAlerts(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeThresholdAlertsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsChangeVpcIpv4(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeVpcIpv4JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsCloneUsingBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsCloneUsingBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsDeleteDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsDeleteDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsDetachBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsDetachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsDisableBackups(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsDisableSelinux(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableSelinuxJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsEnableBackups(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsEnableIpv6(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsIsRunning(ctx context.Context, serverId int64, body PostServersServerIdActionsIsRunningJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsPasswordReset(ctx context.Context, serverId int64, body PostServersServerIdActionsPasswordResetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsPing(ctx context.Context, serverId int64, body PostServersServerIdActionsPingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsPowerCycle(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerCycleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsPowerOff(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOffJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsPowerOn(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOnJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsReboot(ctx context.Context, serverId int64, body PostServersServerIdActionsRebootJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsRebuild(ctx context.Context, serverId int64, body PostServersServerIdActionsRebuildJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsRename(ctx context.Context, serverId int64, body PostServersServerIdActionsRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsResize(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsResizeDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsRestore(ctx context.Context, serverId int64, body PostServersServerIdActionsRestoreJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsShutdown(ctx context.Context, serverId int64, body PostServersServerIdActionsShutdownJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsTakeBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsTakeBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsUncancel(ctx context.Context, serverId int64, body PostServersServerIdActionsUncancelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdActionsUptime(ctx context.Context, serverId int64, body PostServersServerIdActionsUptimeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdActionsActionId request
	GetServersServerIdActionsActionId(ctx context.Context, serverId int64, actionId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdAdvancedFirewallRules request
	GetServersServerIdAdvancedFirewallRules(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdAvailableAdvancedFeatures request
	GetServersServerIdAvailableAdvancedFeatures(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdBackups request
	GetServersServerIdBackups(ctx context.Context, serverId int64, params *GetServersServerIdBackupsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostServersServerIdBackups(ctx context.Context, serverId int64, body PostServersServerIdBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdConsole request
	GetServersServerIdConsole(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdKernels request
	GetServersServerIdKernels(ctx context.Context, serverId int64, params *GetServersServerIdKernelsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdSnapshots request
	GetServersServerIdSnapshots(ctx context.Context, serverId int64, params *GetServersServerIdSnapshotsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdSoftware request
	GetServersServerIdSoftware(ctx context.Context, serverId int64, params *GetServersServerIdSoftwareParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdThresholdAlerts request
	GetServersServerIdThresholdAlerts(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetServersServerIdUserData request
	GetServersServerIdUserData(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSizes request
	GetSizes(ctx context.Context, params *GetSizesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSoftware request
	GetSoftware(ctx context.Context, params *GetSoftwareParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSoftwareOperatingSystemOperatingSystemIdOrSlug request
	GetSoftwareOperatingSystemOperatingSystemIdOrSlug(ctx context.Context, operatingSystemIdOrSlug struct {
		union json.RawMessage
	}, params *GetSoftwareOperatingSystemOperatingSystemIdOrSlugParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSoftwareSoftwareId request
	GetSoftwareSoftwareId(ctx context.Context, softwareId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVpcs request
	GetVpcs(ctx context.Context, params *GetVpcsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostVpcs(ctx context.Context, body PostVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteVpcsVpcId request
	DeleteVpcsVpcId(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVpcsVpcId request
	GetVpcsVpcId(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PatchVpcsVpcId(ctx context.Context, vpcId int64, body PatchVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PutVpcsVpcId(ctx context.Context, vpcId int64, body PutVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVpcsVpcIdMembers request
	GetVpcsVpcIdMembers(ctx context.Context, vpcId int64, params *GetVpcsVpcIdMembersParams, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) GetAccount(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAccountRequest(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) GetAccountKeys(ctx context.Context, params *GetAccountKeysParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAccountKeysRequest(c.Server, params)
	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) PostAccountKeysWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostAccountKeysRequestWithBody(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) PostAccountKeys(ctx context.Context, body PostAccountKeysJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostAccountKeysRequest(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) DeleteAccountKeysKeyId(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteAccountKeysKeyIdRequest(c.Server, keyId)
	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) GetAccountKeysKeyId(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetAccountKeysKeyIdRequest(c.Server, keyId)
	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) PutAccountKeysKeyIdWithBody(ctx context.Context, keyId int, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutAccountKeysKeyIdRequestWithBody(c.Server, keyId, 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) PutAccountKeysKeyId(ctx context.Context, keyId int, body PutAccountKeysKeyIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutAccountKeysKeyIdRequest(c.Server, keyId, 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) GetActions(ctx context.Context, params *GetActionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetActionsRequest(c.Server, params)
	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) GetActionsActionId(ctx context.Context, actionId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetActionsActionIdRequest(c.Server, actionId)
	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) PostActionsActionIdProceedWithBody(ctx context.Context, actionId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostActionsActionIdProceedRequestWithBody(c.Server, actionId, 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) PostActionsActionIdProceed(ctx context.Context, actionId int64, body PostActionsActionIdProceedJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostActionsActionIdProceedRequest(c.Server, actionId, 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) GetCustomersMyBalance(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCustomersMyBalanceRequest(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) GetCustomersMyInvoices(ctx context.Context, params *GetCustomersMyInvoicesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCustomersMyInvoicesRequest(c.Server, params)
	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) GetCustomersMyInvoicesInvoiceId(ctx context.Context, invoiceId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCustomersMyInvoicesInvoiceIdRequest(c.Server, invoiceId)
	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) GetCustomersMyUnpaidPaymentFailedInvoices(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetCustomersMyUnpaidPaymentFailedInvoicesRequest(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) GetDataUsagesCurrent(ctx context.Context, params *GetDataUsagesCurrentParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDataUsagesCurrentRequest(c.Server, params)
	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) GetDataUsagesServerIdCurrent(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDataUsagesServerIdCurrentRequest(c.Server, serverId)
	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) GetDomains(ctx context.Context, params *GetDomainsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDomainsRequest(c.Server, params)
	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) PostDomainsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsRequestWithBody(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) PostDomains(ctx context.Context, body PostDomainsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsRequest(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) GetDomainsNameservers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDomainsNameserversRequest(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) PostDomainsRefreshNameserverCacheWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsRefreshNameserverCacheRequestWithBody(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) PostDomainsRefreshNameserverCache(ctx context.Context, body PostDomainsRefreshNameserverCacheJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsRefreshNameserverCacheRequest(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) DeleteDomainsDomainName(ctx context.Context, domainName struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDomainsDomainNameRequest(c.Server, domainName)
	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) GetDomainsDomainName(ctx context.Context, domainName struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDomainsDomainNameRequest(c.Server, domainName)
	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) GetDomainsDomainNameRecords(ctx context.Context, domainName struct {
	union json.RawMessage
}, params *GetDomainsDomainNameRecordsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDomainsDomainNameRecordsRequest(c.Server, domainName, params)
	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) PostDomainsDomainNameRecordsWithBody(ctx context.Context, domainName struct {
	union json.RawMessage
}, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsDomainNameRecordsRequestWithBody(c.Server, domainName, 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) PostDomainsDomainNameRecords(ctx context.Context, domainName struct {
	union json.RawMessage
}, body PostDomainsDomainNameRecordsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostDomainsDomainNameRecordsRequest(c.Server, domainName, 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) DeleteDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteDomainsDomainNameRecordsRecordIdRequest(c.Server, domainName, recordId)
	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) GetDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDomainsDomainNameRecordsRecordIdRequest(c.Server, domainName, recordId)
	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) PutDomainsDomainNameRecordsRecordIdWithBody(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutDomainsDomainNameRecordsRecordIdRequestWithBody(c.Server, domainName, recordId, 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) PutDomainsDomainNameRecordsRecordId(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, body PutDomainsDomainNameRecordsRecordIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutDomainsDomainNameRecordsRecordIdRequest(c.Server, domainName, recordId, 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) GetImages(ctx context.Context, params *GetImagesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetImagesRequest(c.Server, params)
	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) GetImagesImageIdOrSlug(ctx context.Context, imageIdOrSlug struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetImagesImageIdOrSlugRequest(c.Server, imageIdOrSlug)
	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) GetImagesImageIdDownload(ctx context.Context, imageId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetImagesImageIdDownloadRequest(c.Server, imageId)
	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) GetLoadBalancers(ctx context.Context, params *GetLoadBalancersParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetLoadBalancersRequest(c.Server, params)
	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) PostLoadBalancersWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersRequestWithBody(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) PostLoadBalancers(ctx context.Context, body PostLoadBalancersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersRequest(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) GetLoadBalancersAvailability(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetLoadBalancersAvailabilityRequest(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) DeleteLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteLoadBalancersLoadBalancerIdRequest(c.Server, loadBalancerId)
	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) GetLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetLoadBalancersLoadBalancerIdRequest(c.Server, loadBalancerId)
	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) PutLoadBalancersLoadBalancerIdWithBody(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutLoadBalancersLoadBalancerIdRequestWithBody(c.Server, loadBalancerId, 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) PutLoadBalancersLoadBalancerId(ctx context.Context, loadBalancerId int64, body PutLoadBalancersLoadBalancerIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutLoadBalancersLoadBalancerIdRequest(c.Server, loadBalancerId, 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) DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBody(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteLoadBalancersLoadBalancerIdForwardingRulesRequestWithBody(c.Server, loadBalancerId, 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) DeleteLoadBalancersLoadBalancerIdForwardingRules(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteLoadBalancersLoadBalancerIdForwardingRulesRequest(c.Server, loadBalancerId, 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) PostLoadBalancersLoadBalancerIdForwardingRulesWithBody(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersLoadBalancerIdForwardingRulesRequestWithBody(c.Server, loadBalancerId, 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) PostLoadBalancersLoadBalancerIdForwardingRules(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersLoadBalancerIdForwardingRulesRequest(c.Server, loadBalancerId, 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) DeleteLoadBalancersLoadBalancerIdServersWithBody(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteLoadBalancersLoadBalancerIdServersRequestWithBody(c.Server, loadBalancerId, 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) DeleteLoadBalancersLoadBalancerIdServers(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteLoadBalancersLoadBalancerIdServersRequest(c.Server, loadBalancerId, 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) PostLoadBalancersLoadBalancerIdServersWithBody(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersLoadBalancerIdServersRequestWithBody(c.Server, loadBalancerId, 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) PostLoadBalancersLoadBalancerIdServers(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostLoadBalancersLoadBalancerIdServersRequest(c.Server, loadBalancerId, 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) GetRegions(ctx context.Context, params *GetRegionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetRegionsRequest(c.Server, params)
	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) GetReverseNamesIpv6(ctx context.Context, params *GetReverseNamesIpv6Params, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetReverseNamesIpv6Request(c.Server, params)
	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) PostReverseNamesIpv6WithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostReverseNamesIpv6RequestWithBody(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) PostReverseNamesIpv6(ctx context.Context, body PostReverseNamesIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostReverseNamesIpv6Request(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) GetSamplesetsServerId(ctx context.Context, serverId int64, params *GetSamplesetsServerIdParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSamplesetsServerIdRequest(c.Server, serverId, params)
	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) GetSamplesetsServerIdLatest(ctx context.Context, serverId int64, params *GetSamplesetsServerIdLatestParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSamplesetsServerIdLatestRequest(c.Server, serverId, params)
	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) GetServers(ctx context.Context, params *GetServersParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersRequest(c.Server, params)
	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) PostServersWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersRequestWithBody(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) PostServers(ctx context.Context, body PostServersJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersRequest(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) GetServersThresholdAlerts(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersThresholdAlertsRequest(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) DeleteServersServerId(ctx context.Context, serverId int64, params *DeleteServersServerIdParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteServersServerIdRequest(c.Server, serverId, params)
	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) GetServersServerId(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdRequest(c.Server, serverId)
	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) GetServersServerIdActions(ctx context.Context, serverId int64, params *GetServersServerIdActionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdActionsRequest(c.Server, serverId, params)
	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) PostServersServerIdActionsWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRequestWithBody(c.Server, serverId, 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) PostServersServerIdActions(ctx context.Context, serverId int64, body PostServersServerIdActionsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRequest(c.Server, serverId, 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) PostServersServerIdActionsAddDiskWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsAddDiskRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsAddDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsAddDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsAddDiskRequest(c.Server, serverId, 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) PostServersServerIdActionsAttachBackupWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsAttachBackupRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsAttachBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsAttachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsAttachBackupRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeAdvancedFeaturesWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeAdvancedFeaturesRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeAdvancedFeatures(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFeaturesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeAdvancedFeaturesRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeAdvancedFirewallRulesWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeAdvancedFirewallRulesRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeAdvancedFirewallRules(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFirewallRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeAdvancedFirewallRulesRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeBackupScheduleWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeBackupScheduleRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeBackupSchedule(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeBackupScheduleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeBackupScheduleRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeIpv6WithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeIpv6RequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeIpv6(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeIpv6Request(c.Server, serverId, 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) PostServersServerIdActionsChangeIpv6ReverseNameserversWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeIpv6ReverseNameserversRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeIpv6ReverseNameservers(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6ReverseNameserversJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeIpv6ReverseNameserversRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeKernelWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeKernelRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeKernel(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeKernelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeKernelRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeManageOffsiteBackupCopiesRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeManageOffsiteBackupCopies(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeManageOffsiteBackupCopiesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeManageOffsiteBackupCopiesRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeNetworkWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeNetworkRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeNetwork(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeNetworkRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeOffsiteBackupLocationWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeOffsiteBackupLocationRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeOffsiteBackupLocation(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeOffsiteBackupLocationJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeOffsiteBackupLocationRequest(c.Server, serverId, 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) PostServersServerIdActionsChangePartnerWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangePartnerRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangePartner(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePartnerJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangePartnerRequest(c.Server, serverId, 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) PostServersServerIdActionsChangePortBlockingWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangePortBlockingRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangePortBlocking(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePortBlockingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangePortBlockingRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeRegionWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeRegionRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeRegion(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeRegionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeRegionRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeReverseNameWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeReverseNameRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeReverseName(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeReverseNameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeReverseNameRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeSeparatePrivateNetworkInterface(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeSourceAndDestinationCheckWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeSourceAndDestinationCheckRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeSourceAndDestinationCheck(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSourceAndDestinationCheckJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeSourceAndDestinationCheckRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeThresholdAlertsWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeThresholdAlertsRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeThresholdAlerts(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeThresholdAlertsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeThresholdAlertsRequest(c.Server, serverId, 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) PostServersServerIdActionsChangeVpcIpv4WithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeVpcIpv4RequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsChangeVpcIpv4(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeVpcIpv4JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsChangeVpcIpv4Request(c.Server, serverId, 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) PostServersServerIdActionsCloneUsingBackupWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsCloneUsingBackupRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsCloneUsingBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsCloneUsingBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsCloneUsingBackupRequest(c.Server, serverId, 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) PostServersServerIdActionsDeleteDiskWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDeleteDiskRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsDeleteDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsDeleteDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDeleteDiskRequest(c.Server, serverId, 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) PostServersServerIdActionsDetachBackupWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDetachBackupRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsDetachBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsDetachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDetachBackupRequest(c.Server, serverId, 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) PostServersServerIdActionsDisableBackupsWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDisableBackupsRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsDisableBackups(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDisableBackupsRequest(c.Server, serverId, 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) PostServersServerIdActionsDisableSelinuxWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDisableSelinuxRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsDisableSelinux(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableSelinuxJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsDisableSelinuxRequest(c.Server, serverId, 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) PostServersServerIdActionsEnableBackupsWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsEnableBackupsRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsEnableBackups(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsEnableBackupsRequest(c.Server, serverId, 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) PostServersServerIdActionsEnableIpv6WithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsEnableIpv6RequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsEnableIpv6(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsEnableIpv6Request(c.Server, serverId, 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) PostServersServerIdActionsIsRunningWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsIsRunningRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsIsRunning(ctx context.Context, serverId int64, body PostServersServerIdActionsIsRunningJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsIsRunningRequest(c.Server, serverId, 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) PostServersServerIdActionsPasswordResetWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPasswordResetRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsPasswordReset(ctx context.Context, serverId int64, body PostServersServerIdActionsPasswordResetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPasswordResetRequest(c.Server, serverId, 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) PostServersServerIdActionsPingWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPingRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsPing(ctx context.Context, serverId int64, body PostServersServerIdActionsPingJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPingRequest(c.Server, serverId, 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) PostServersServerIdActionsPowerCycleWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerCycleRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsPowerCycle(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerCycleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerCycleRequest(c.Server, serverId, 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) PostServersServerIdActionsPowerOffWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerOffRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsPowerOff(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOffJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerOffRequest(c.Server, serverId, 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) PostServersServerIdActionsPowerOnWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerOnRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsPowerOn(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOnJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsPowerOnRequest(c.Server, serverId, 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) PostServersServerIdActionsRebootWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRebootRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsReboot(ctx context.Context, serverId int64, body PostServersServerIdActionsRebootJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRebootRequest(c.Server, serverId, 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) PostServersServerIdActionsRebuildWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRebuildRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsRebuild(ctx context.Context, serverId int64, body PostServersServerIdActionsRebuildJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRebuildRequest(c.Server, serverId, 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) PostServersServerIdActionsRenameWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRenameRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsRename(ctx context.Context, serverId int64, body PostServersServerIdActionsRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRenameRequest(c.Server, serverId, 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) PostServersServerIdActionsResizeWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsResizeRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsResize(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsResizeRequest(c.Server, serverId, 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) PostServersServerIdActionsResizeDiskWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsResizeDiskRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsResizeDisk(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsResizeDiskRequest(c.Server, serverId, 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) PostServersServerIdActionsRestoreWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRestoreRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsRestore(ctx context.Context, serverId int64, body PostServersServerIdActionsRestoreJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsRestoreRequest(c.Server, serverId, 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) PostServersServerIdActionsShutdownWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsShutdownRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsShutdown(ctx context.Context, serverId int64, body PostServersServerIdActionsShutdownJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsShutdownRequest(c.Server, serverId, 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) PostServersServerIdActionsTakeBackupWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsTakeBackupRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsTakeBackup(ctx context.Context, serverId int64, body PostServersServerIdActionsTakeBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsTakeBackupRequest(c.Server, serverId, 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) PostServersServerIdActionsUncancelWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsUncancelRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsUncancel(ctx context.Context, serverId int64, body PostServersServerIdActionsUncancelJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsUncancelRequest(c.Server, serverId, 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) PostServersServerIdActionsUptimeWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsUptimeRequestWithBody(c.Server, serverId, 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) PostServersServerIdActionsUptime(ctx context.Context, serverId int64, body PostServersServerIdActionsUptimeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdActionsUptimeRequest(c.Server, serverId, 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) GetServersServerIdActionsActionId(ctx context.Context, serverId int64, actionId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdActionsActionIdRequest(c.Server, serverId, actionId)
	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) GetServersServerIdAdvancedFirewallRules(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdAdvancedFirewallRulesRequest(c.Server, serverId)
	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) GetServersServerIdAvailableAdvancedFeatures(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdAvailableAdvancedFeaturesRequest(c.Server, serverId)
	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) GetServersServerIdBackups(ctx context.Context, serverId int64, params *GetServersServerIdBackupsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdBackupsRequest(c.Server, serverId, params)
	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) PostServersServerIdBackupsWithBody(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdBackupsRequestWithBody(c.Server, serverId, 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) PostServersServerIdBackups(ctx context.Context, serverId int64, body PostServersServerIdBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostServersServerIdBackupsRequest(c.Server, serverId, 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) GetServersServerIdConsole(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdConsoleRequest(c.Server, serverId)
	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) GetServersServerIdKernels(ctx context.Context, serverId int64, params *GetServersServerIdKernelsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdKernelsRequest(c.Server, serverId, params)
	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) GetServersServerIdSnapshots(ctx context.Context, serverId int64, params *GetServersServerIdSnapshotsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdSnapshotsRequest(c.Server, serverId, params)
	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) GetServersServerIdSoftware(ctx context.Context, serverId int64, params *GetServersServerIdSoftwareParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdSoftwareRequest(c.Server, serverId, params)
	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) GetServersServerIdThresholdAlerts(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdThresholdAlertsRequest(c.Server, serverId)
	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) GetServersServerIdUserData(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetServersServerIdUserDataRequest(c.Server, serverId)
	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) GetSizes(ctx context.Context, params *GetSizesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSizesRequest(c.Server, params)
	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) GetSoftware(ctx context.Context, params *GetSoftwareParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSoftwareRequest(c.Server, params)
	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) GetSoftwareOperatingSystemOperatingSystemIdOrSlug(ctx context.Context, operatingSystemIdOrSlug struct {
	union json.RawMessage
}, params *GetSoftwareOperatingSystemOperatingSystemIdOrSlugParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSoftwareOperatingSystemOperatingSystemIdOrSlugRequest(c.Server, operatingSystemIdOrSlug, params)
	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) GetSoftwareSoftwareId(ctx context.Context, softwareId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetSoftwareSoftwareIdRequest(c.Server, softwareId)
	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) GetVpcs(ctx context.Context, params *GetVpcsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetVpcsRequest(c.Server, params)
	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) PostVpcsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostVpcsRequestWithBody(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) PostVpcs(ctx context.Context, body PostVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostVpcsRequest(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) DeleteVpcsVpcId(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteVpcsVpcIdRequest(c.Server, vpcId)
	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) GetVpcsVpcId(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetVpcsVpcIdRequest(c.Server, vpcId)
	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) PatchVpcsVpcIdWithBody(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPatchVpcsVpcIdRequestWithBody(c.Server, vpcId, 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) PatchVpcsVpcId(ctx context.Context, vpcId int64, body PatchVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPatchVpcsVpcIdRequest(c.Server, vpcId, 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) PutVpcsVpcIdWithBody(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutVpcsVpcIdRequestWithBody(c.Server, vpcId, 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) PutVpcsVpcId(ctx context.Context, vpcId int64, body PutVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPutVpcsVpcIdRequest(c.Server, vpcId, 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) GetVpcsVpcIdMembers(ctx context.Context, vpcId int64, params *GetVpcsVpcIdMembersParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetVpcsVpcIdMembersRequest(c.Server, vpcId, params)
	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)
}

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

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

	operationPath := fmt.Sprintf("/account")
	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
}

// NewGetAccountKeysRequest generates requests for GetAccountKeys
func NewGetAccountKeysRequest(server string, params *GetAccountKeysParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostAccountKeysRequestWithBody generates requests for PostAccountKeys with any type of body
func NewPostAccountKeysRequestWithBody(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("/account/keys")
	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
}

// NewDeleteAccountKeysKeyIdRequest generates requests for DeleteAccountKeysKeyId
func NewDeleteAccountKeysKeyIdRequest(server string, keyId int) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "key_id", keyId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/account/keys/%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
}

// NewGetAccountKeysKeyIdRequest generates requests for GetAccountKeysKeyId
func NewGetAccountKeysKeyIdRequest(server string, keyId int) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "key_id", keyId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/account/keys/%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
}

// NewPutAccountKeysKeyIdRequest calls the generic PutAccountKeysKeyId builder with application/json body
func NewPutAccountKeysKeyIdRequest(server string, keyId int, body PutAccountKeysKeyIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPutAccountKeysKeyIdRequestWithBody(server, keyId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "key_id", keyId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: ""})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewGetActionsRequest generates requests for GetActions
func NewGetActionsRequest(server string, params *GetActionsParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetActionsActionIdRequest generates requests for GetActionsActionId
func NewGetActionsActionIdRequest(server string, actionId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "action_id", actionId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/actions/%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
}

// NewPostActionsActionIdProceedRequest calls the generic PostActionsActionIdProceed builder with application/json body
func NewPostActionsActionIdProceedRequest(server string, actionId int64, body PostActionsActionIdProceedJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostActionsActionIdProceedRequestWithBody(server, actionId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "action_id", actionId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/actions/%s/proceed", 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
}

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

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

	operationPath := fmt.Sprintf("/customers/my/balance")
	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
}

// NewGetCustomersMyInvoicesRequest generates requests for GetCustomersMyInvoices
func NewGetCustomersMyInvoicesRequest(server string, params *GetCustomersMyInvoicesParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetCustomersMyInvoicesInvoiceIdRequest generates requests for GetCustomersMyInvoicesInvoiceId
func NewGetCustomersMyInvoicesInvoiceIdRequest(server string, invoiceId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "invoice_id", invoiceId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/customers/my/invoices/%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
}

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

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

	operationPath := fmt.Sprintf("/customers/my/unpaid-payment-failed-invoices")
	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
}

// NewGetDataUsagesCurrentRequest generates requests for GetDataUsagesCurrent
func NewGetDataUsagesCurrentRequest(server string, params *GetDataUsagesCurrentParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetDataUsagesServerIdCurrentRequest generates requests for GetDataUsagesServerIdCurrent
func NewGetDataUsagesServerIdCurrentRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/data_usages/%s/current", 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
}

// NewGetDomainsRequest generates requests for GetDomains
func NewGetDomainsRequest(server string, params *GetDomainsParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostDomainsRequestWithBody generates requests for PostDomains with any type of body
func NewPostDomainsRequestWithBody(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("/domains")
	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
}

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

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

	operationPath := fmt.Sprintf("/domains/nameservers")
	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
}

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

// NewPostDomainsRefreshNameserverCacheRequestWithBody generates requests for PostDomainsRefreshNameserverCache with any type of body
func NewPostDomainsRefreshNameserverCacheRequestWithBody(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("/domains/refresh_nameserver_cache")
	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
}

// NewDeleteDomainsDomainNameRequest generates requests for DeleteDomainsDomainName
func NewDeleteDomainsDomainNameRequest(server string, domainName struct {
	union json.RawMessage
}) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/domains/%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
}

// NewGetDomainsDomainNameRequest generates requests for GetDomainsDomainName
func NewGetDomainsDomainNameRequest(server string, domainName struct {
	union json.RawMessage
}) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/domains/%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
}

// NewGetDomainsDomainNameRecordsRequest generates requests for GetDomainsDomainNameRecords
func NewGetDomainsDomainNameRecordsRequest(server string, domainName struct {
	union json.RawMessage
}, params *GetDomainsDomainNameRecordsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Type != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "type", *params.Type, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Name != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "name", *params.Name, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewPostDomainsDomainNameRecordsRequest calls the generic PostDomainsDomainNameRecords builder with application/json body
func NewPostDomainsDomainNameRecordsRequest(server string, domainName struct {
	union json.RawMessage
}, body PostDomainsDomainNameRecordsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostDomainsDomainNameRecordsRequestWithBody(server, domainName, "application/json", bodyReader)
}

// NewPostDomainsDomainNameRecordsRequestWithBody generates requests for PostDomainsDomainNameRecords with any type of body
func NewPostDomainsDomainNameRecordsRequestWithBody(server string, domainName struct {
	union json.RawMessage
}, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/domains/%s/records", 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
}

// NewDeleteDomainsDomainNameRecordsRecordIdRequest generates requests for DeleteDomainsDomainNameRecordsRecordId
func NewDeleteDomainsDomainNameRecordsRecordIdRequest(server string, domainName struct {
	union json.RawMessage
}, recordId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "record_id", recordId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/domains/%s/records/%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
}

// NewGetDomainsDomainNameRecordsRecordIdRequest generates requests for GetDomainsDomainNameRecordsRecordId
func NewGetDomainsDomainNameRecordsRecordIdRequest(server string, domainName struct {
	union json.RawMessage
}, recordId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "record_id", recordId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/domains/%s/records/%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
}

// NewPutDomainsDomainNameRecordsRecordIdRequest calls the generic PutDomainsDomainNameRecordsRecordId builder with application/json body
func NewPutDomainsDomainNameRecordsRecordIdRequest(server string, domainName struct {
	union json.RawMessage
}, recordId int64, body PutDomainsDomainNameRecordsRecordIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPutDomainsDomainNameRecordsRecordIdRequestWithBody(server, domainName, recordId, "application/json", bodyReader)
}

// NewPutDomainsDomainNameRecordsRecordIdRequestWithBody generates requests for PutDomainsDomainNameRecordsRecordId with any type of body
func NewPutDomainsDomainNameRecordsRecordIdRequestWithBody(server string, domainName struct {
	union json.RawMessage
}, recordId int64, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "domain_name", domainName, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "record_id", recordId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewGetImagesRequest generates requests for GetImages
func NewGetImagesRequest(server string, params *GetImagesParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Type != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "type", *params.Type, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Private != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "private", *params.Private, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "boolean", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetImagesImageIdOrSlugRequest generates requests for GetImagesImageIdOrSlug
func NewGetImagesImageIdOrSlugRequest(server string, imageIdOrSlug struct {
	union json.RawMessage
}) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "image_id_or_slug", imageIdOrSlug, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/images/%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
}

// NewGetImagesImageIdDownloadRequest generates requests for GetImagesImageIdDownload
func NewGetImagesImageIdDownloadRequest(server string, imageId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "image_id", imageId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/images/%s/download", 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
}

// NewGetLoadBalancersRequest generates requests for GetLoadBalancers
func NewGetLoadBalancersRequest(server string, params *GetLoadBalancersParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostLoadBalancersRequestWithBody generates requests for PostLoadBalancers with any type of body
func NewPostLoadBalancersRequestWithBody(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("/load_balancers")
	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
}

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

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

	operationPath := fmt.Sprintf("/load_balancers/availability")
	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
}

// NewDeleteLoadBalancersLoadBalancerIdRequest generates requests for DeleteLoadBalancersLoadBalancerId
func NewDeleteLoadBalancersLoadBalancerIdRequest(server string, loadBalancerId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/load_balancers/%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
}

// NewGetLoadBalancersLoadBalancerIdRequest generates requests for GetLoadBalancersLoadBalancerId
func NewGetLoadBalancersLoadBalancerIdRequest(server string, loadBalancerId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/load_balancers/%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
}

// NewPutLoadBalancersLoadBalancerIdRequest calls the generic PutLoadBalancersLoadBalancerId builder with application/json body
func NewPutLoadBalancersLoadBalancerIdRequest(server string, loadBalancerId int64, body PutLoadBalancersLoadBalancerIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPutLoadBalancersLoadBalancerIdRequestWithBody(server, loadBalancerId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewDeleteLoadBalancersLoadBalancerIdForwardingRulesRequest calls the generic DeleteLoadBalancersLoadBalancerIdForwardingRules builder with application/json body
func NewDeleteLoadBalancersLoadBalancerIdForwardingRulesRequest(server string, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDeleteLoadBalancersLoadBalancerIdForwardingRulesRequestWithBody(server, loadBalancerId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewPostLoadBalancersLoadBalancerIdForwardingRulesRequest calls the generic PostLoadBalancersLoadBalancerIdForwardingRules builder with application/json body
func NewPostLoadBalancersLoadBalancerIdForwardingRulesRequest(server string, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostLoadBalancersLoadBalancerIdForwardingRulesRequestWithBody(server, loadBalancerId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/load_balancers/%s/forwarding_rules", 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
}

// NewDeleteLoadBalancersLoadBalancerIdServersRequest calls the generic DeleteLoadBalancersLoadBalancerIdServers builder with application/json body
func NewDeleteLoadBalancersLoadBalancerIdServersRequest(server string, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdServersJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDeleteLoadBalancersLoadBalancerIdServersRequestWithBody(server, loadBalancerId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewPostLoadBalancersLoadBalancerIdServersRequest calls the generic PostLoadBalancersLoadBalancerIdServers builder with application/json body
func NewPostLoadBalancersLoadBalancerIdServersRequest(server string, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdServersJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostLoadBalancersLoadBalancerIdServersRequestWithBody(server, loadBalancerId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "load_balancer_id", loadBalancerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/load_balancers/%s/servers", 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
}

// NewGetRegionsRequest generates requests for GetRegions
func NewGetRegionsRequest(server string, params *GetRegionsParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetReverseNamesIpv6Request generates requests for GetReverseNamesIpv6
func NewGetReverseNamesIpv6Request(server string, params *GetReverseNamesIpv6Params) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostReverseNamesIpv6RequestWithBody generates requests for PostReverseNamesIpv6 with any type of body
func NewPostReverseNamesIpv6RequestWithBody(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("/reverse_names/ipv6")
	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
}

// NewGetSamplesetsServerIdRequest generates requests for GetSamplesetsServerId
func NewGetSamplesetsServerIdRequest(server string, serverId int64, params *GetSamplesetsServerIdParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.DataInterval != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "data_interval", *params.DataInterval, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Start != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "start", *params.Start, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: "date-time"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.End != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "end", *params.End, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: "date-time"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetSamplesetsServerIdLatestRequest generates requests for GetSamplesetsServerIdLatest
func NewGetSamplesetsServerIdLatestRequest(server string, serverId int64, params *GetSamplesetsServerIdLatestParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.DataInterval != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "data_interval", *params.DataInterval, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetServersRequest generates requests for GetServers
func NewGetServersRequest(server string, params *GetServersParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Hostname != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "hostname", *params.Hostname, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostServersRequestWithBody generates requests for PostServers with any type of body
func NewPostServersRequestWithBody(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("/servers")
	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
}

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

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

	operationPath := fmt.Sprintf("/servers/threshold_alerts")
	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
}

// NewDeleteServersServerIdRequest generates requests for DeleteServersServerId
func NewDeleteServersServerIdRequest(server string, serverId int64, params *DeleteServersServerIdParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Reason != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "reason", *params.Reason, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetServersServerIdRequest generates requests for GetServersServerId
func NewGetServersServerIdRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%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
}

// NewGetServersServerIdActionsRequest generates requests for GetServersServerIdActions
func NewGetServersServerIdActionsRequest(server string, serverId int64, params *GetServersServerIdActionsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewPostServersServerIdActionsRequest calls the generic PostServersServerIdActions builder with application/json body
func NewPostServersServerIdActionsRequest(server string, serverId int64, body PostServersServerIdActionsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions", 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
}

// NewPostServersServerIdActionsAddDiskRequest calls the generic PostServersServerIdActionsAddDisk builder with application/json body
func NewPostServersServerIdActionsAddDiskRequest(server string, serverId int64, body PostServersServerIdActionsAddDiskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsAddDiskRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#AddDisk", 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
}

// NewPostServersServerIdActionsAttachBackupRequest calls the generic PostServersServerIdActionsAttachBackup builder with application/json body
func NewPostServersServerIdActionsAttachBackupRequest(server string, serverId int64, body PostServersServerIdActionsAttachBackupJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsAttachBackupRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#AttachBackup", 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
}

// NewPostServersServerIdActionsChangeAdvancedFeaturesRequest calls the generic PostServersServerIdActionsChangeAdvancedFeatures builder with application/json body
func NewPostServersServerIdActionsChangeAdvancedFeaturesRequest(server string, serverId int64, body PostServersServerIdActionsChangeAdvancedFeaturesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeAdvancedFeaturesRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeAdvancedFeatures", 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
}

// NewPostServersServerIdActionsChangeAdvancedFirewallRulesRequest calls the generic PostServersServerIdActionsChangeAdvancedFirewallRules builder with application/json body
func NewPostServersServerIdActionsChangeAdvancedFirewallRulesRequest(server string, serverId int64, body PostServersServerIdActionsChangeAdvancedFirewallRulesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeAdvancedFirewallRulesRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeAdvancedFirewallRules", 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
}

// NewPostServersServerIdActionsChangeBackupScheduleRequest calls the generic PostServersServerIdActionsChangeBackupSchedule builder with application/json body
func NewPostServersServerIdActionsChangeBackupScheduleRequest(server string, serverId int64, body PostServersServerIdActionsChangeBackupScheduleJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeBackupScheduleRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeBackupSchedule", 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
}

// NewPostServersServerIdActionsChangeIpv6Request calls the generic PostServersServerIdActionsChangeIpv6 builder with application/json body
func NewPostServersServerIdActionsChangeIpv6Request(server string, serverId int64, body PostServersServerIdActionsChangeIpv6JSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeIpv6RequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeIpv6", 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
}

// NewPostServersServerIdActionsChangeIpv6ReverseNameserversRequest calls the generic PostServersServerIdActionsChangeIpv6ReverseNameservers builder with application/json body
func NewPostServersServerIdActionsChangeIpv6ReverseNameserversRequest(server string, serverId int64, body PostServersServerIdActionsChangeIpv6ReverseNameserversJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeIpv6ReverseNameserversRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeIpv6ReverseNameservers", 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
}

// NewPostServersServerIdActionsChangeKernelRequest calls the generic PostServersServerIdActionsChangeKernel builder with application/json body
func NewPostServersServerIdActionsChangeKernelRequest(server string, serverId int64, body PostServersServerIdActionsChangeKernelJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeKernelRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeKernel", 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
}

// NewPostServersServerIdActionsChangeManageOffsiteBackupCopiesRequest calls the generic PostServersServerIdActionsChangeManageOffsiteBackupCopies builder with application/json body
func NewPostServersServerIdActionsChangeManageOffsiteBackupCopiesRequest(server string, serverId int64, body PostServersServerIdActionsChangeManageOffsiteBackupCopiesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeManageOffsiteBackupCopiesRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeManageOffsiteBackupCopies", 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
}

// NewPostServersServerIdActionsChangeNetworkRequest calls the generic PostServersServerIdActionsChangeNetwork builder with application/json body
func NewPostServersServerIdActionsChangeNetworkRequest(server string, serverId int64, body PostServersServerIdActionsChangeNetworkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeNetworkRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeNetwork", 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
}

// NewPostServersServerIdActionsChangeOffsiteBackupLocationRequest calls the generic PostServersServerIdActionsChangeOffsiteBackupLocation builder with application/json body
func NewPostServersServerIdActionsChangeOffsiteBackupLocationRequest(server string, serverId int64, body PostServersServerIdActionsChangeOffsiteBackupLocationJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeOffsiteBackupLocationRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeOffsiteBackupLocation", 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
}

// NewPostServersServerIdActionsChangePartnerRequest calls the generic PostServersServerIdActionsChangePartner builder with application/json body
func NewPostServersServerIdActionsChangePartnerRequest(server string, serverId int64, body PostServersServerIdActionsChangePartnerJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangePartnerRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangePartner", 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
}

// NewPostServersServerIdActionsChangePortBlockingRequest calls the generic PostServersServerIdActionsChangePortBlocking builder with application/json body
func NewPostServersServerIdActionsChangePortBlockingRequest(server string, serverId int64, body PostServersServerIdActionsChangePortBlockingJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangePortBlockingRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangePortBlocking", 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
}

// NewPostServersServerIdActionsChangeRegionRequest calls the generic PostServersServerIdActionsChangeRegion builder with application/json body
func NewPostServersServerIdActionsChangeRegionRequest(server string, serverId int64, body PostServersServerIdActionsChangeRegionJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeRegionRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeRegion", 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
}

// NewPostServersServerIdActionsChangeReverseNameRequest calls the generic PostServersServerIdActionsChangeReverseName builder with application/json body
func NewPostServersServerIdActionsChangeReverseNameRequest(server string, serverId int64, body PostServersServerIdActionsChangeReverseNameJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeReverseNameRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeReverseName", 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
}

// NewPostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceRequest calls the generic PostServersServerIdActionsChangeSeparatePrivateNetworkInterface builder with application/json body
func NewPostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceRequest(server string, serverId int64, body PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeSeparatePrivateNetworkInterface", 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
}

// NewPostServersServerIdActionsChangeSourceAndDestinationCheckRequest calls the generic PostServersServerIdActionsChangeSourceAndDestinationCheck builder with application/json body
func NewPostServersServerIdActionsChangeSourceAndDestinationCheckRequest(server string, serverId int64, body PostServersServerIdActionsChangeSourceAndDestinationCheckJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeSourceAndDestinationCheckRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeSourceAndDestinationCheck", 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
}

// NewPostServersServerIdActionsChangeThresholdAlertsRequest calls the generic PostServersServerIdActionsChangeThresholdAlerts builder with application/json body
func NewPostServersServerIdActionsChangeThresholdAlertsRequest(server string, serverId int64, body PostServersServerIdActionsChangeThresholdAlertsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeThresholdAlertsRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeThresholdAlerts", 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
}

// NewPostServersServerIdActionsChangeVpcIpv4Request calls the generic PostServersServerIdActionsChangeVpcIpv4 builder with application/json body
func NewPostServersServerIdActionsChangeVpcIpv4Request(server string, serverId int64, body PostServersServerIdActionsChangeVpcIpv4JSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsChangeVpcIpv4RequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ChangeVpcIpv4", 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
}

// NewPostServersServerIdActionsCloneUsingBackupRequest calls the generic PostServersServerIdActionsCloneUsingBackup builder with application/json body
func NewPostServersServerIdActionsCloneUsingBackupRequest(server string, serverId int64, body PostServersServerIdActionsCloneUsingBackupJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsCloneUsingBackupRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#CloneUsingBackup", 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
}

// NewPostServersServerIdActionsDeleteDiskRequest calls the generic PostServersServerIdActionsDeleteDisk builder with application/json body
func NewPostServersServerIdActionsDeleteDiskRequest(server string, serverId int64, body PostServersServerIdActionsDeleteDiskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsDeleteDiskRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#DeleteDisk", 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
}

// NewPostServersServerIdActionsDetachBackupRequest calls the generic PostServersServerIdActionsDetachBackup builder with application/json body
func NewPostServersServerIdActionsDetachBackupRequest(server string, serverId int64, body PostServersServerIdActionsDetachBackupJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsDetachBackupRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#DetachBackup", 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
}

// NewPostServersServerIdActionsDisableBackupsRequest calls the generic PostServersServerIdActionsDisableBackups builder with application/json body
func NewPostServersServerIdActionsDisableBackupsRequest(server string, serverId int64, body PostServersServerIdActionsDisableBackupsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsDisableBackupsRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#DisableBackups", 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
}

// NewPostServersServerIdActionsDisableSelinuxRequest calls the generic PostServersServerIdActionsDisableSelinux builder with application/json body
func NewPostServersServerIdActionsDisableSelinuxRequest(server string, serverId int64, body PostServersServerIdActionsDisableSelinuxJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsDisableSelinuxRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#DisableSelinux", 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
}

// NewPostServersServerIdActionsEnableBackupsRequest calls the generic PostServersServerIdActionsEnableBackups builder with application/json body
func NewPostServersServerIdActionsEnableBackupsRequest(server string, serverId int64, body PostServersServerIdActionsEnableBackupsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsEnableBackupsRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#EnableBackups", 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
}

// NewPostServersServerIdActionsEnableIpv6Request calls the generic PostServersServerIdActionsEnableIpv6 builder with application/json body
func NewPostServersServerIdActionsEnableIpv6Request(server string, serverId int64, body PostServersServerIdActionsEnableIpv6JSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsEnableIpv6RequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#EnableIpv6", 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
}

// NewPostServersServerIdActionsIsRunningRequest calls the generic PostServersServerIdActionsIsRunning builder with application/json body
func NewPostServersServerIdActionsIsRunningRequest(server string, serverId int64, body PostServersServerIdActionsIsRunningJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsIsRunningRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#IsRunning", 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
}

// NewPostServersServerIdActionsPasswordResetRequest calls the generic PostServersServerIdActionsPasswordReset builder with application/json body
func NewPostServersServerIdActionsPasswordResetRequest(server string, serverId int64, body PostServersServerIdActionsPasswordResetJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsPasswordResetRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#PasswordReset", 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
}

// NewPostServersServerIdActionsPingRequest calls the generic PostServersServerIdActionsPing builder with application/json body
func NewPostServersServerIdActionsPingRequest(server string, serverId int64, body PostServersServerIdActionsPingJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsPingRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Ping", 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
}

// NewPostServersServerIdActionsPowerCycleRequest calls the generic PostServersServerIdActionsPowerCycle builder with application/json body
func NewPostServersServerIdActionsPowerCycleRequest(server string, serverId int64, body PostServersServerIdActionsPowerCycleJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsPowerCycleRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#PowerCycle", 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
}

// NewPostServersServerIdActionsPowerOffRequest calls the generic PostServersServerIdActionsPowerOff builder with application/json body
func NewPostServersServerIdActionsPowerOffRequest(server string, serverId int64, body PostServersServerIdActionsPowerOffJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsPowerOffRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#PowerOff", 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
}

// NewPostServersServerIdActionsPowerOnRequest calls the generic PostServersServerIdActionsPowerOn builder with application/json body
func NewPostServersServerIdActionsPowerOnRequest(server string, serverId int64, body PostServersServerIdActionsPowerOnJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsPowerOnRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#PowerOn", 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
}

// NewPostServersServerIdActionsRebootRequest calls the generic PostServersServerIdActionsReboot builder with application/json body
func NewPostServersServerIdActionsRebootRequest(server string, serverId int64, body PostServersServerIdActionsRebootJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsRebootRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Reboot", 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
}

// NewPostServersServerIdActionsRebuildRequest calls the generic PostServersServerIdActionsRebuild builder with application/json body
func NewPostServersServerIdActionsRebuildRequest(server string, serverId int64, body PostServersServerIdActionsRebuildJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsRebuildRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Rebuild", 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
}

// NewPostServersServerIdActionsRenameRequest calls the generic PostServersServerIdActionsRename builder with application/json body
func NewPostServersServerIdActionsRenameRequest(server string, serverId int64, body PostServersServerIdActionsRenameJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsRenameRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Rename", 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
}

// NewPostServersServerIdActionsResizeRequest calls the generic PostServersServerIdActionsResize builder with application/json body
func NewPostServersServerIdActionsResizeRequest(server string, serverId int64, body PostServersServerIdActionsResizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsResizeRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Resize", 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
}

// NewPostServersServerIdActionsResizeDiskRequest calls the generic PostServersServerIdActionsResizeDisk builder with application/json body
func NewPostServersServerIdActionsResizeDiskRequest(server string, serverId int64, body PostServersServerIdActionsResizeDiskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsResizeDiskRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#ResizeDisk", 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
}

// NewPostServersServerIdActionsRestoreRequest calls the generic PostServersServerIdActionsRestore builder with application/json body
func NewPostServersServerIdActionsRestoreRequest(server string, serverId int64, body PostServersServerIdActionsRestoreJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsRestoreRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Restore", 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
}

// NewPostServersServerIdActionsShutdownRequest calls the generic PostServersServerIdActionsShutdown builder with application/json body
func NewPostServersServerIdActionsShutdownRequest(server string, serverId int64, body PostServersServerIdActionsShutdownJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsShutdownRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Shutdown", 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
}

// NewPostServersServerIdActionsTakeBackupRequest calls the generic PostServersServerIdActionsTakeBackup builder with application/json body
func NewPostServersServerIdActionsTakeBackupRequest(server string, serverId int64, body PostServersServerIdActionsTakeBackupJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsTakeBackupRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#TakeBackup", 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
}

// NewPostServersServerIdActionsUncancelRequest calls the generic PostServersServerIdActionsUncancel builder with application/json body
func NewPostServersServerIdActionsUncancelRequest(server string, serverId int64, body PostServersServerIdActionsUncancelJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsUncancelRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Uncancel", 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
}

// NewPostServersServerIdActionsUptimeRequest calls the generic PostServersServerIdActionsUptime builder with application/json body
func NewPostServersServerIdActionsUptimeRequest(server string, serverId int64, body PostServersServerIdActionsUptimeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdActionsUptimeRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions#Uptime", 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
}

// NewGetServersServerIdActionsActionIdRequest generates requests for GetServersServerIdActionsActionId
func NewGetServersServerIdActionsActionIdRequest(server string, serverId int64, actionId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithOptions("simple", false, "action_id", actionId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/actions/%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
}

// NewGetServersServerIdAdvancedFirewallRulesRequest generates requests for GetServersServerIdAdvancedFirewallRules
func NewGetServersServerIdAdvancedFirewallRulesRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/advanced_firewall_rules", 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
}

// NewGetServersServerIdAvailableAdvancedFeaturesRequest generates requests for GetServersServerIdAvailableAdvancedFeatures
func NewGetServersServerIdAvailableAdvancedFeaturesRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/available_advanced_features", 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
}

// NewGetServersServerIdBackupsRequest generates requests for GetServersServerIdBackups
func NewGetServersServerIdBackupsRequest(server string, serverId int64, params *GetServersServerIdBackupsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewPostServersServerIdBackupsRequest calls the generic PostServersServerIdBackups builder with application/json body
func NewPostServersServerIdBackupsRequest(server string, serverId int64, body PostServersServerIdBackupsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostServersServerIdBackupsRequestWithBody(server, serverId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/backups", 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
}

// NewGetServersServerIdConsoleRequest generates requests for GetServersServerIdConsole
func NewGetServersServerIdConsoleRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/console", 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
}

// NewGetServersServerIdKernelsRequest generates requests for GetServersServerIdKernels
func NewGetServersServerIdKernelsRequest(server string, serverId int64, params *GetServersServerIdKernelsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetServersServerIdSnapshotsRequest generates requests for GetServersServerIdSnapshots
func NewGetServersServerIdSnapshotsRequest(server string, serverId int64, params *GetServersServerIdSnapshotsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetServersServerIdSoftwareRequest generates requests for GetServersServerIdSoftware
func NewGetServersServerIdSoftwareRequest(server string, serverId int64, params *GetServersServerIdSoftwareParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetServersServerIdThresholdAlertsRequest generates requests for GetServersServerIdThresholdAlerts
func NewGetServersServerIdThresholdAlertsRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/threshold_alerts", 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
}

// NewGetServersServerIdUserDataRequest generates requests for GetServersServerIdUserData
func NewGetServersServerIdUserDataRequest(server string, serverId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "server_id", serverId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/servers/%s/user_data", 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
}

// NewGetSizesRequest generates requests for GetSizes
func NewGetSizesRequest(server string, params *GetSizesParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.ServerId != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "server_id", *params.ServerId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int64"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Image != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "image", *params.Image, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetSoftwareRequest generates requests for GetSoftware
func NewGetSoftwareRequest(server string, params *GetSoftwareParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetSoftwareOperatingSystemOperatingSystemIdOrSlugRequest generates requests for GetSoftwareOperatingSystemOperatingSystemIdOrSlug
func NewGetSoftwareOperatingSystemOperatingSystemIdOrSlugRequest(server string, operatingSystemIdOrSlug struct {
	union json.RawMessage
}, params *GetSoftwareOperatingSystemOperatingSystemIdOrSlugParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "operating_system_id_or_slug", operatingSystemIdOrSlug, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "", Format: ""})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

// NewGetSoftwareSoftwareIdRequest generates requests for GetSoftwareSoftwareId
func NewGetSoftwareSoftwareIdRequest(server string, softwareId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "software_id", softwareId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/software/%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
}

// NewGetVpcsRequest generates requests for GetVpcs
func NewGetVpcsRequest(server string, params *GetVpcsParams) (*http.Request, error) {
	var err error

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

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

	return req, nil
}

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

// NewPostVpcsRequestWithBody generates requests for PostVpcs with any type of body
func NewPostVpcsRequestWithBody(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("/vpcs")
	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
}

// NewDeleteVpcsVpcIdRequest generates requests for DeleteVpcsVpcId
func NewDeleteVpcsVpcIdRequest(server string, vpcId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "vpc_id", vpcId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/vpcs/%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
}

// NewGetVpcsVpcIdRequest generates requests for GetVpcsVpcId
func NewGetVpcsVpcIdRequest(server string, vpcId int64) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "vpc_id", vpcId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/vpcs/%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
}

// NewPatchVpcsVpcIdRequest calls the generic PatchVpcsVpcId builder with application/json body
func NewPatchVpcsVpcIdRequest(server string, vpcId int64, body PatchVpcsVpcIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPatchVpcsVpcIdRequestWithBody(server, vpcId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "vpc_id", vpcId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewPutVpcsVpcIdRequest calls the generic PutVpcsVpcId builder with application/json body
func NewPutVpcsVpcIdRequest(server string, vpcId int64, body PutVpcsVpcIdJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPutVpcsVpcIdRequestWithBody(server, vpcId, "application/json", bodyReader)
}

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

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "vpc_id", vpcId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

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

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

	return req, nil
}

// NewGetVpcsVpcIdMembersRequest generates requests for GetVpcsVpcIdMembers
func NewGetVpcsVpcIdMembersRequest(server string, vpcId int64, params *GetVpcsVpcIdMembersParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "vpc_id", vpcId, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "integer", Format: "int64"})
	if err != nil {
		return nil, err
	}

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

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

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

	if params != nil {
		queryValues := queryURL.Query()

		if params.ResourceType != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "resource_type", *params.ResourceType, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "", Format: ""}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Page != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "page", *params.Page, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.PerPage != nil {

			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "per_page", *params.PerPage, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int32"}); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	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 {
	// GetAccountWithResponse request
	GetAccountWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAccountResponse, error)

	// GetAccountKeysWithResponse request
	GetAccountKeysWithResponse(ctx context.Context, params *GetAccountKeysParams, reqEditors ...RequestEditorFn) (*GetAccountKeysResponse, error)

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

	PostAccountKeysWithResponse(ctx context.Context, body PostAccountKeysJSONRequestBody, reqEditors ...RequestEditorFn) (*PostAccountKeysResponse, error)

	// DeleteAccountKeysKeyIdWithResponse request
	DeleteAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*DeleteAccountKeysKeyIdResponse, error)

	// GetAccountKeysKeyIdWithResponse request
	GetAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*GetAccountKeysKeyIdResponse, error)

	// PutAccountKeysKeyIdWithBodyWithResponse request with any body
	PutAccountKeysKeyIdWithBodyWithResponse(ctx context.Context, keyId int, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutAccountKeysKeyIdResponse, error)

	PutAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, body PutAccountKeysKeyIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutAccountKeysKeyIdResponse, error)

	// GetActionsWithResponse request
	GetActionsWithResponse(ctx context.Context, params *GetActionsParams, reqEditors ...RequestEditorFn) (*GetActionsResponse, error)

	// GetActionsActionIdWithResponse request
	GetActionsActionIdWithResponse(ctx context.Context, actionId int64, reqEditors ...RequestEditorFn) (*GetActionsActionIdResponse, error)

	// PostActionsActionIdProceedWithBodyWithResponse request with any body
	PostActionsActionIdProceedWithBodyWithResponse(ctx context.Context, actionId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostActionsActionIdProceedResponse, error)

	PostActionsActionIdProceedWithResponse(ctx context.Context, actionId int64, body PostActionsActionIdProceedJSONRequestBody, reqEditors ...RequestEditorFn) (*PostActionsActionIdProceedResponse, error)

	// GetCustomersMyBalanceWithResponse request
	GetCustomersMyBalanceWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCustomersMyBalanceResponse, error)

	// GetCustomersMyInvoicesWithResponse request
	GetCustomersMyInvoicesWithResponse(ctx context.Context, params *GetCustomersMyInvoicesParams, reqEditors ...RequestEditorFn) (*GetCustomersMyInvoicesResponse, error)

	// GetCustomersMyInvoicesInvoiceIdWithResponse request
	GetCustomersMyInvoicesInvoiceIdWithResponse(ctx context.Context, invoiceId int64, reqEditors ...RequestEditorFn) (*GetCustomersMyInvoicesInvoiceIdResponse, error)

	// GetCustomersMyUnpaidPaymentFailedInvoicesWithResponse request
	GetCustomersMyUnpaidPaymentFailedInvoicesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCustomersMyUnpaidPaymentFailedInvoicesResponse, error)

	// GetDataUsagesCurrentWithResponse request
	GetDataUsagesCurrentWithResponse(ctx context.Context, params *GetDataUsagesCurrentParams, reqEditors ...RequestEditorFn) (*GetDataUsagesCurrentResponse, error)

	// GetDataUsagesServerIdCurrentWithResponse request
	GetDataUsagesServerIdCurrentWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetDataUsagesServerIdCurrentResponse, error)

	// GetDomainsWithResponse request
	GetDomainsWithResponse(ctx context.Context, params *GetDomainsParams, reqEditors ...RequestEditorFn) (*GetDomainsResponse, error)

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

	PostDomainsWithResponse(ctx context.Context, body PostDomainsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsResponse, error)

	// GetDomainsNameserversWithResponse request
	GetDomainsNameserversWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDomainsNameserversResponse, error)

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

	PostDomainsRefreshNameserverCacheWithResponse(ctx context.Context, body PostDomainsRefreshNameserverCacheJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsRefreshNameserverCacheResponse, error)

	// DeleteDomainsDomainNameWithResponse request
	DeleteDomainsDomainNameWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*DeleteDomainsDomainNameResponse, error)

	// GetDomainsDomainNameWithResponse request
	GetDomainsDomainNameWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameResponse, error)

	// GetDomainsDomainNameRecordsWithResponse request
	GetDomainsDomainNameRecordsWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, params *GetDomainsDomainNameRecordsParams, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameRecordsResponse, error)

	// PostDomainsDomainNameRecordsWithBodyWithResponse request with any body
	PostDomainsDomainNameRecordsWithBodyWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostDomainsDomainNameRecordsResponse, error)

	PostDomainsDomainNameRecordsWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, body PostDomainsDomainNameRecordsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsDomainNameRecordsResponse, error)

	// DeleteDomainsDomainNameRecordsRecordIdWithResponse request
	DeleteDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, reqEditors ...RequestEditorFn) (*DeleteDomainsDomainNameRecordsRecordIdResponse, error)

	// GetDomainsDomainNameRecordsRecordIdWithResponse request
	GetDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameRecordsRecordIdResponse, error)

	// PutDomainsDomainNameRecordsRecordIdWithBodyWithResponse request with any body
	PutDomainsDomainNameRecordsRecordIdWithBodyWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutDomainsDomainNameRecordsRecordIdResponse, error)

	PutDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
		union json.RawMessage
	}, recordId int64, body PutDomainsDomainNameRecordsRecordIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutDomainsDomainNameRecordsRecordIdResponse, error)

	// GetImagesWithResponse request
	GetImagesWithResponse(ctx context.Context, params *GetImagesParams, reqEditors ...RequestEditorFn) (*GetImagesResponse, error)

	// GetImagesImageIdOrSlugWithResponse request
	GetImagesImageIdOrSlugWithResponse(ctx context.Context, imageIdOrSlug struct {
		union json.RawMessage
	}, reqEditors ...RequestEditorFn) (*GetImagesImageIdOrSlugResponse, error)

	// GetImagesImageIdDownloadWithResponse request
	GetImagesImageIdDownloadWithResponse(ctx context.Context, imageId int64, reqEditors ...RequestEditorFn) (*GetImagesImageIdDownloadResponse, error)

	// GetLoadBalancersWithResponse request
	GetLoadBalancersWithResponse(ctx context.Context, params *GetLoadBalancersParams, reqEditors ...RequestEditorFn) (*GetLoadBalancersResponse, error)

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

	PostLoadBalancersWithResponse(ctx context.Context, body PostLoadBalancersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersResponse, error)

	// GetLoadBalancersAvailabilityWithResponse request
	GetLoadBalancersAvailabilityWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetLoadBalancersAvailabilityResponse, error)

	// DeleteLoadBalancersLoadBalancerIdWithResponse request
	DeleteLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdResponse, error)

	// GetLoadBalancersLoadBalancerIdWithResponse request
	GetLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*GetLoadBalancersLoadBalancerIdResponse, error)

	// PutLoadBalancersLoadBalancerIdWithBodyWithResponse request with any body
	PutLoadBalancersLoadBalancerIdWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutLoadBalancersLoadBalancerIdResponse, error)

	PutLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, body PutLoadBalancersLoadBalancerIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutLoadBalancersLoadBalancerIdResponse, error)

	// DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse request with any body
	DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse, error)

	DeleteLoadBalancersLoadBalancerIdForwardingRulesWithResponse(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse, error)

	// PostLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse request with any body
	PostLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdForwardingRulesResponse, error)

	PostLoadBalancersLoadBalancerIdForwardingRulesWithResponse(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdForwardingRulesResponse, error)

	// DeleteLoadBalancersLoadBalancerIdServersWithBodyWithResponse request with any body
	DeleteLoadBalancersLoadBalancerIdServersWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdServersResponse, error)

	DeleteLoadBalancersLoadBalancerIdServersWithResponse(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdServersResponse, error)

	// PostLoadBalancersLoadBalancerIdServersWithBodyWithResponse request with any body
	PostLoadBalancersLoadBalancerIdServersWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdServersResponse, error)

	PostLoadBalancersLoadBalancerIdServersWithResponse(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdServersResponse, error)

	// GetRegionsWithResponse request
	GetRegionsWithResponse(ctx context.Context, params *GetRegionsParams, reqEditors ...RequestEditorFn) (*GetRegionsResponse, error)

	// GetReverseNamesIpv6WithResponse request
	GetReverseNamesIpv6WithResponse(ctx context.Context, params *GetReverseNamesIpv6Params, reqEditors ...RequestEditorFn) (*GetReverseNamesIpv6Response, error)

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

	PostReverseNamesIpv6WithResponse(ctx context.Context, body PostReverseNamesIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostReverseNamesIpv6Response, error)

	// GetSamplesetsServerIdWithResponse request
	GetSamplesetsServerIdWithResponse(ctx context.Context, serverId int64, params *GetSamplesetsServerIdParams, reqEditors ...RequestEditorFn) (*GetSamplesetsServerIdResponse, error)

	// GetSamplesetsServerIdLatestWithResponse request
	GetSamplesetsServerIdLatestWithResponse(ctx context.Context, serverId int64, params *GetSamplesetsServerIdLatestParams, reqEditors ...RequestEditorFn) (*GetSamplesetsServerIdLatestResponse, error)

	// GetServersWithResponse request
	GetServersWithResponse(ctx context.Context, params *GetServersParams, reqEditors ...RequestEditorFn) (*GetServersResponse, error)

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

	PostServersWithResponse(ctx context.Context, body PostServersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersResponse, error)

	// GetServersThresholdAlertsWithResponse request
	GetServersThresholdAlertsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetServersThresholdAlertsResponse, error)

	// DeleteServersServerIdWithResponse request
	DeleteServersServerIdWithResponse(ctx context.Context, serverId int64, params *DeleteServersServerIdParams, reqEditors ...RequestEditorFn) (*DeleteServersServerIdResponse, error)

	// GetServersServerIdWithResponse request
	GetServersServerIdWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdResponse, error)

	// GetServersServerIdActionsWithResponse request
	GetServersServerIdActionsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdActionsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdActionsResponse, error)

	// PostServersServerIdActionsWithBodyWithResponse request with any body
	PostServersServerIdActionsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResponse, error)

	PostServersServerIdActionsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResponse, error)

	// PostServersServerIdActionsAddDiskWithBodyWithResponse request with any body
	PostServersServerIdActionsAddDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAddDiskResponse, error)

	PostServersServerIdActionsAddDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsAddDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAddDiskResponse, error)

	// PostServersServerIdActionsAttachBackupWithBodyWithResponse request with any body
	PostServersServerIdActionsAttachBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAttachBackupResponse, error)

	PostServersServerIdActionsAttachBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsAttachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAttachBackupResponse, error)

	// PostServersServerIdActionsChangeAdvancedFeaturesWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeAdvancedFeaturesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFeaturesResponse, error)

	PostServersServerIdActionsChangeAdvancedFeaturesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFeaturesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFeaturesResponse, error)

	// PostServersServerIdActionsChangeAdvancedFirewallRulesWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeAdvancedFirewallRulesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFirewallRulesResponse, error)

	PostServersServerIdActionsChangeAdvancedFirewallRulesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFirewallRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFirewallRulesResponse, error)

	// PostServersServerIdActionsChangeBackupScheduleWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeBackupScheduleWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeBackupScheduleResponse, error)

	PostServersServerIdActionsChangeBackupScheduleWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeBackupScheduleJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeBackupScheduleResponse, error)

	// PostServersServerIdActionsChangeIpv6WithBodyWithResponse request with any body
	PostServersServerIdActionsChangeIpv6WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6Response, error)

	PostServersServerIdActionsChangeIpv6WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6Response, error)

	// PostServersServerIdActionsChangeIpv6ReverseNameserversWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeIpv6ReverseNameserversWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6ReverseNameserversResponse, error)

	PostServersServerIdActionsChangeIpv6ReverseNameserversWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6ReverseNameserversJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6ReverseNameserversResponse, error)

	// PostServersServerIdActionsChangeKernelWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeKernelWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeKernelResponse, error)

	PostServersServerIdActionsChangeKernelWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeKernelJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeKernelResponse, error)

	// PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse, error)

	PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeManageOffsiteBackupCopiesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse, error)

	// PostServersServerIdActionsChangeNetworkWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeNetworkWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeNetworkResponse, error)

	PostServersServerIdActionsChangeNetworkWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeNetworkResponse, error)

	// PostServersServerIdActionsChangeOffsiteBackupLocationWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeOffsiteBackupLocationWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeOffsiteBackupLocationResponse, error)

	PostServersServerIdActionsChangeOffsiteBackupLocationWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeOffsiteBackupLocationJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeOffsiteBackupLocationResponse, error)

	// PostServersServerIdActionsChangePartnerWithBodyWithResponse request with any body
	PostServersServerIdActionsChangePartnerWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePartnerResponse, error)

	PostServersServerIdActionsChangePartnerWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePartnerJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePartnerResponse, error)

	// PostServersServerIdActionsChangePortBlockingWithBodyWithResponse request with any body
	PostServersServerIdActionsChangePortBlockingWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePortBlockingResponse, error)

	PostServersServerIdActionsChangePortBlockingWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePortBlockingJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePortBlockingResponse, error)

	// PostServersServerIdActionsChangeRegionWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeRegionWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeRegionResponse, error)

	PostServersServerIdActionsChangeRegionWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeRegionJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeRegionResponse, error)

	// PostServersServerIdActionsChangeReverseNameWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeReverseNameWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeReverseNameResponse, error)

	PostServersServerIdActionsChangeReverseNameWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeReverseNameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeReverseNameResponse, error)

	// PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse, error)

	PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse, error)

	// PostServersServerIdActionsChangeSourceAndDestinationCheckWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeSourceAndDestinationCheckWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSourceAndDestinationCheckResponse, error)

	PostServersServerIdActionsChangeSourceAndDestinationCheckWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSourceAndDestinationCheckJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSourceAndDestinationCheckResponse, error)

	// PostServersServerIdActionsChangeThresholdAlertsWithBodyWithResponse request with any body
	PostServersServerIdActionsChangeThresholdAlertsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeThresholdAlertsResponse, error)

	PostServersServerIdActionsChangeThresholdAlertsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeThresholdAlertsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeThresholdAlertsResponse, error)

	// PostServersServerIdActionsChangeVpcIpv4WithBodyWithResponse request with any body
	PostServersServerIdActionsChangeVpcIpv4WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeVpcIpv4Response, error)

	PostServersServerIdActionsChangeVpcIpv4WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeVpcIpv4JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeVpcIpv4Response, error)

	// PostServersServerIdActionsCloneUsingBackupWithBodyWithResponse request with any body
	PostServersServerIdActionsCloneUsingBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsCloneUsingBackupResponse, error)

	PostServersServerIdActionsCloneUsingBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsCloneUsingBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsCloneUsingBackupResponse, error)

	// PostServersServerIdActionsDeleteDiskWithBodyWithResponse request with any body
	PostServersServerIdActionsDeleteDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDeleteDiskResponse, error)

	PostServersServerIdActionsDeleteDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDeleteDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDeleteDiskResponse, error)

	// PostServersServerIdActionsDetachBackupWithBodyWithResponse request with any body
	PostServersServerIdActionsDetachBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDetachBackupResponse, error)

	PostServersServerIdActionsDetachBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDetachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDetachBackupResponse, error)

	// PostServersServerIdActionsDisableBackupsWithBodyWithResponse request with any body
	PostServersServerIdActionsDisableBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableBackupsResponse, error)

	PostServersServerIdActionsDisableBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableBackupsResponse, error)

	// PostServersServerIdActionsDisableSelinuxWithBodyWithResponse request with any body
	PostServersServerIdActionsDisableSelinuxWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableSelinuxResponse, error)

	PostServersServerIdActionsDisableSelinuxWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableSelinuxJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableSelinuxResponse, error)

	// PostServersServerIdActionsEnableBackupsWithBodyWithResponse request with any body
	PostServersServerIdActionsEnableBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableBackupsResponse, error)

	PostServersServerIdActionsEnableBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableBackupsResponse, error)

	// PostServersServerIdActionsEnableIpv6WithBodyWithResponse request with any body
	PostServersServerIdActionsEnableIpv6WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableIpv6Response, error)

	PostServersServerIdActionsEnableIpv6WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableIpv6Response, error)

	// PostServersServerIdActionsIsRunningWithBodyWithResponse request with any body
	PostServersServerIdActionsIsRunningWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsIsRunningResponse, error)

	PostServersServerIdActionsIsRunningWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsIsRunningJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsIsRunningResponse, error)

	// PostServersServerIdActionsPasswordResetWithBodyWithResponse request with any body
	PostServersServerIdActionsPasswordResetWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPasswordResetResponse, error)

	PostServersServerIdActionsPasswordResetWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPasswordResetJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPasswordResetResponse, error)

	// PostServersServerIdActionsPingWithBodyWithResponse request with any body
	PostServersServerIdActionsPingWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPingResponse, error)

	PostServersServerIdActionsPingWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPingJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPingResponse, error)

	// PostServersServerIdActionsPowerCycleWithBodyWithResponse request with any body
	PostServersServerIdActionsPowerCycleWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerCycleResponse, error)

	PostServersServerIdActionsPowerCycleWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerCycleJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerCycleResponse, error)

	// PostServersServerIdActionsPowerOffWithBodyWithResponse request with any body
	PostServersServerIdActionsPowerOffWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOffResponse, error)

	PostServersServerIdActionsPowerOffWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOffJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOffResponse, error)

	// PostServersServerIdActionsPowerOnWithBodyWithResponse request with any body
	PostServersServerIdActionsPowerOnWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOnResponse, error)

	PostServersServerIdActionsPowerOnWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOnJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOnResponse, error)

	// PostServersServerIdActionsRebootWithBodyWithResponse request with any body
	PostServersServerIdActionsRebootWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebootResponse, error)

	PostServersServerIdActionsRebootWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRebootJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebootResponse, error)

	// PostServersServerIdActionsRebuildWithBodyWithResponse request with any body
	PostServersServerIdActionsRebuildWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebuildResponse, error)

	PostServersServerIdActionsRebuildWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRebuildJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebuildResponse, error)

	// PostServersServerIdActionsRenameWithBodyWithResponse request with any body
	PostServersServerIdActionsRenameWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRenameResponse, error)

	PostServersServerIdActionsRenameWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRenameResponse, error)

	// PostServersServerIdActionsResizeWithBodyWithResponse request with any body
	PostServersServerIdActionsResizeWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeResponse, error)

	PostServersServerIdActionsResizeWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeResponse, error)

	// PostServersServerIdActionsResizeDiskWithBodyWithResponse request with any body
	PostServersServerIdActionsResizeDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeDiskResponse, error)

	PostServersServerIdActionsResizeDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeDiskResponse, error)

	// PostServersServerIdActionsRestoreWithBodyWithResponse request with any body
	PostServersServerIdActionsRestoreWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRestoreResponse, error)

	PostServersServerIdActionsRestoreWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRestoreJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRestoreResponse, error)

	// PostServersServerIdActionsShutdownWithBodyWithResponse request with any body
	PostServersServerIdActionsShutdownWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsShutdownResponse, error)

	PostServersServerIdActionsShutdownWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsShutdownJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsShutdownResponse, error)

	// PostServersServerIdActionsTakeBackupWithBodyWithResponse request with any body
	PostServersServerIdActionsTakeBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsTakeBackupResponse, error)

	PostServersServerIdActionsTakeBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsTakeBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsTakeBackupResponse, error)

	// PostServersServerIdActionsUncancelWithBodyWithResponse request with any body
	PostServersServerIdActionsUncancelWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUncancelResponse, error)

	PostServersServerIdActionsUncancelWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsUncancelJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUncancelResponse, error)

	// PostServersServerIdActionsUptimeWithBodyWithResponse request with any body
	PostServersServerIdActionsUptimeWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUptimeResponse, error)

	PostServersServerIdActionsUptimeWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsUptimeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUptimeResponse, error)

	// GetServersServerIdActionsActionIdWithResponse request
	GetServersServerIdActionsActionIdWithResponse(ctx context.Context, serverId int64, actionId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdActionsActionIdResponse, error)

	// GetServersServerIdAdvancedFirewallRulesWithResponse request
	GetServersServerIdAdvancedFirewallRulesWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdAdvancedFirewallRulesResponse, error)

	// GetServersServerIdAvailableAdvancedFeaturesWithResponse request
	GetServersServerIdAvailableAdvancedFeaturesWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdAvailableAdvancedFeaturesResponse, error)

	// GetServersServerIdBackupsWithResponse request
	GetServersServerIdBackupsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdBackupsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdBackupsResponse, error)

	// PostServersServerIdBackupsWithBodyWithResponse request with any body
	PostServersServerIdBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdBackupsResponse, error)

	PostServersServerIdBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdBackupsResponse, error)

	// GetServersServerIdConsoleWithResponse request
	GetServersServerIdConsoleWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdConsoleResponse, error)

	// GetServersServerIdKernelsWithResponse request
	GetServersServerIdKernelsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdKernelsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdKernelsResponse, error)

	// GetServersServerIdSnapshotsWithResponse request
	GetServersServerIdSnapshotsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdSnapshotsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdSnapshotsResponse, error)

	// GetServersServerIdSoftwareWithResponse request
	GetServersServerIdSoftwareWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdSoftwareParams, reqEditors ...RequestEditorFn) (*GetServersServerIdSoftwareResponse, error)

	// GetServersServerIdThresholdAlertsWithResponse request
	GetServersServerIdThresholdAlertsWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdThresholdAlertsResponse, error)

	// GetServersServerIdUserDataWithResponse request
	GetServersServerIdUserDataWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdUserDataResponse, error)

	// GetSizesWithResponse request
	GetSizesWithResponse(ctx context.Context, params *GetSizesParams, reqEditors ...RequestEditorFn) (*GetSizesResponse, error)

	// GetSoftwareWithResponse request
	GetSoftwareWithResponse(ctx context.Context, params *GetSoftwareParams, reqEditors ...RequestEditorFn) (*GetSoftwareResponse, error)

	// GetSoftwareOperatingSystemOperatingSystemIdOrSlugWithResponse request
	GetSoftwareOperatingSystemOperatingSystemIdOrSlugWithResponse(ctx context.Context, operatingSystemIdOrSlug struct {
		union json.RawMessage
	}, params *GetSoftwareOperatingSystemOperatingSystemIdOrSlugParams, reqEditors ...RequestEditorFn) (*GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse, error)

	// GetSoftwareSoftwareIdWithResponse request
	GetSoftwareSoftwareIdWithResponse(ctx context.Context, softwareId int64, reqEditors ...RequestEditorFn) (*GetSoftwareSoftwareIdResponse, error)

	// GetVpcsWithResponse request
	GetVpcsWithResponse(ctx context.Context, params *GetVpcsParams, reqEditors ...RequestEditorFn) (*GetVpcsResponse, error)

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

	PostVpcsWithResponse(ctx context.Context, body PostVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostVpcsResponse, error)

	// DeleteVpcsVpcIdWithResponse request
	DeleteVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*DeleteVpcsVpcIdResponse, error)

	// GetVpcsVpcIdWithResponse request
	GetVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*GetVpcsVpcIdResponse, error)

	// PatchVpcsVpcIdWithBodyWithResponse request with any body
	PatchVpcsVpcIdWithBodyWithResponse(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchVpcsVpcIdResponse, error)

	PatchVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, body PatchVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchVpcsVpcIdResponse, error)

	// PutVpcsVpcIdWithBodyWithResponse request with any body
	PutVpcsVpcIdWithBodyWithResponse(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutVpcsVpcIdResponse, error)

	PutVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, body PutVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutVpcsVpcIdResponse, error)

	// GetVpcsVpcIdMembersWithResponse request
	GetVpcsVpcIdMembersWithResponse(ctx context.Context, vpcId int64, params *GetVpcsVpcIdMembersParams, reqEditors ...RequestEditorFn) (*GetVpcsVpcIdMembersResponse, error)
}

type GetAccountResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AccountResponse
}

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

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

type GetAccountKeysResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SshKeysResponse
}

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

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

type PostAccountKeysResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SshKeyResponse
}

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

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

type DeleteAccountKeysKeyIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetAccountKeysKeyIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SshKeyResponse
}

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

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

type PutAccountKeysKeyIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SshKeyResponse
}

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

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

type GetActionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionsResponse
}

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

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

type GetActionsActionIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostActionsActionIdProceedResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetCustomersMyBalanceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *BalanceResponse
}

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

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

type GetCustomersMyInvoicesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *InvoicesResponse
}

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

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

type GetCustomersMyInvoicesInvoiceIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *InvoiceResponse
}

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

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

type GetCustomersMyUnpaidPaymentFailedInvoicesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *UnpaidFailedInvoicesResponse
}

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

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

type GetDataUsagesCurrentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DataUsagesResponse
}

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

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

type GetDataUsagesServerIdCurrentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DataUsageResponse
}

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

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

type GetDomainsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainsResponse
}

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

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

type PostDomainsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainResponse
}

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

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

type GetDomainsNameserversResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LocalNameserversResponse
}

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

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

type PostDomainsRefreshNameserverCacheResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type DeleteDomainsDomainNameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetDomainsDomainNameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainResponse
}

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

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

type GetDomainsDomainNameRecordsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainRecordsResponse
}

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

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

type PostDomainsDomainNameRecordsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainRecordResponse
}

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

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

type DeleteDomainsDomainNameRecordsRecordIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetDomainsDomainNameRecordsRecordIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainRecordResponse
}

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

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

type PutDomainsDomainNameRecordsRecordIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *DomainRecordResponse
}

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

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

type GetImagesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ImagesResponse
}

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

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

type GetImagesImageIdOrSlugResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ImageResponse
}

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

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

type GetImagesImageIdDownloadResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ImageDownloadResponse
}

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

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

type GetLoadBalancersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LoadBalancersResponse
}

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

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

type PostLoadBalancersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CreateLoadBalancerResponse
}

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

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

type GetLoadBalancersAvailabilityResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LoadBalancerAvailabilityResponse
}

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

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

type DeleteLoadBalancersLoadBalancerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetLoadBalancersLoadBalancerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LoadBalancerResponse
}

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

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

type PutLoadBalancersLoadBalancerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *UpdateLoadBalancerResponse
}

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

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

type DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type PostLoadBalancersLoadBalancerIdForwardingRulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type DeleteLoadBalancersLoadBalancerIdServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type PostLoadBalancersLoadBalancerIdServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetRegionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RegionsResponse
}

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

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

type GetReverseNamesIpv6Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ReverseNameServersResponse
}

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

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

type PostReverseNamesIpv6Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type GetSamplesetsServerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SampleSetsResponse
}

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

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

type GetSamplesetsServerIdLatestResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SampleSetResponse
}

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

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

type GetServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ServersResponse
}

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

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

type PostServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CreateServerResponse
}

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

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

type GetServersThresholdAlertsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *CurrentServerAlertsResponse
}

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

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

type DeleteServersServerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetServersServerIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ServerResponse
}

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

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

type GetServersServerIdActionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionsResponse
}

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

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

type PostServersServerIdActionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsAddDiskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsAttachBackupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeAdvancedFeaturesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeAdvancedFirewallRulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeBackupScheduleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeIpv6Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeIpv6ReverseNameserversResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeKernelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeNetworkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeOffsiteBackupLocationResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangePartnerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangePortBlockingResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeRegionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeReverseNameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeSourceAndDestinationCheckResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeThresholdAlertsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsChangeVpcIpv4Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsCloneUsingBackupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsDeleteDiskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsDetachBackupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsDisableBackupsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsDisableSelinuxResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsEnableBackupsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsEnableIpv6Response struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsIsRunningResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsPasswordResetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsPingResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsPowerCycleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsPowerOffResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsPowerOnResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsRebootResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsRebuildResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsRenameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsResizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsResizeDiskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsRestoreResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsShutdownResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsTakeBackupResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsUncancelResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type PostServersServerIdActionsUptimeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type GetServersServerIdActionsActionIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type GetServersServerIdAdvancedFirewallRulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AdvancedFirewallRulesResponse
}

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

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

type GetServersServerIdAvailableAdvancedFeaturesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AvailableAdvancedServerFeaturesResponse
}

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

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

type GetServersServerIdBackupsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *BackupsResponse
}

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

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

type PostServersServerIdBackupsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ActionResponse
}

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

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

type GetServersServerIdConsoleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ConsoleResponse
}

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

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

type GetServersServerIdKernelsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *KernelsResponse
}

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

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

type GetServersServerIdSnapshotsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SnapshotsResponse
}

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

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

type GetServersServerIdSoftwareResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *LicensedSoftwaresResponse
}

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

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

type GetServersServerIdThresholdAlertsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ThresholdAlertsResponse
}

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

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

type GetServersServerIdUserDataResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *UserData
}

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

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

type GetSizesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SizesResponse
}

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

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

type GetSoftwareResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SoftwaresResponse
}

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

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

type GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SoftwaresResponse
}

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

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

type GetSoftwareSoftwareIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SoftwareResponse
}

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

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

type GetVpcsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcsResponse
}

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

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

type PostVpcsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcResponse
}

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

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

type DeleteVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

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

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

type GetVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcResponse
}

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

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

type PatchVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcResponse
}

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

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

type PutVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcResponse
}

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

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

type GetVpcsVpcIdMembersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VpcMembersResponse
}

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

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

// GetAccountWithResponse request returning *GetAccountResponse
func (c *ClientWithResponses) GetAccountWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAccountResponse, error) {
	rsp, err := c.GetAccount(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAccountResponse(rsp)
}

// GetAccountKeysWithResponse request returning *GetAccountKeysResponse
func (c *ClientWithResponses) GetAccountKeysWithResponse(ctx context.Context, params *GetAccountKeysParams, reqEditors ...RequestEditorFn) (*GetAccountKeysResponse, error) {
	rsp, err := c.GetAccountKeys(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAccountKeysResponse(rsp)
}

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

func (c *ClientWithResponses) PostAccountKeysWithResponse(ctx context.Context, body PostAccountKeysJSONRequestBody, reqEditors ...RequestEditorFn) (*PostAccountKeysResponse, error) {
	rsp, err := c.PostAccountKeys(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostAccountKeysResponse(rsp)
}

// DeleteAccountKeysKeyIdWithResponse request returning *DeleteAccountKeysKeyIdResponse
func (c *ClientWithResponses) DeleteAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*DeleteAccountKeysKeyIdResponse, error) {
	rsp, err := c.DeleteAccountKeysKeyId(ctx, keyId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteAccountKeysKeyIdResponse(rsp)
}

// GetAccountKeysKeyIdWithResponse request returning *GetAccountKeysKeyIdResponse
func (c *ClientWithResponses) GetAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, reqEditors ...RequestEditorFn) (*GetAccountKeysKeyIdResponse, error) {
	rsp, err := c.GetAccountKeysKeyId(ctx, keyId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetAccountKeysKeyIdResponse(rsp)
}

// PutAccountKeysKeyIdWithBodyWithResponse request with arbitrary body returning *PutAccountKeysKeyIdResponse
func (c *ClientWithResponses) PutAccountKeysKeyIdWithBodyWithResponse(ctx context.Context, keyId int, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutAccountKeysKeyIdResponse, error) {
	rsp, err := c.PutAccountKeysKeyIdWithBody(ctx, keyId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutAccountKeysKeyIdResponse(rsp)
}

func (c *ClientWithResponses) PutAccountKeysKeyIdWithResponse(ctx context.Context, keyId int, body PutAccountKeysKeyIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutAccountKeysKeyIdResponse, error) {
	rsp, err := c.PutAccountKeysKeyId(ctx, keyId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutAccountKeysKeyIdResponse(rsp)
}

// GetActionsWithResponse request returning *GetActionsResponse
func (c *ClientWithResponses) GetActionsWithResponse(ctx context.Context, params *GetActionsParams, reqEditors ...RequestEditorFn) (*GetActionsResponse, error) {
	rsp, err := c.GetActions(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetActionsResponse(rsp)
}

// GetActionsActionIdWithResponse request returning *GetActionsActionIdResponse
func (c *ClientWithResponses) GetActionsActionIdWithResponse(ctx context.Context, actionId int64, reqEditors ...RequestEditorFn) (*GetActionsActionIdResponse, error) {
	rsp, err := c.GetActionsActionId(ctx, actionId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetActionsActionIdResponse(rsp)
}

// PostActionsActionIdProceedWithBodyWithResponse request with arbitrary body returning *PostActionsActionIdProceedResponse
func (c *ClientWithResponses) PostActionsActionIdProceedWithBodyWithResponse(ctx context.Context, actionId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostActionsActionIdProceedResponse, error) {
	rsp, err := c.PostActionsActionIdProceedWithBody(ctx, actionId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostActionsActionIdProceedResponse(rsp)
}

func (c *ClientWithResponses) PostActionsActionIdProceedWithResponse(ctx context.Context, actionId int64, body PostActionsActionIdProceedJSONRequestBody, reqEditors ...RequestEditorFn) (*PostActionsActionIdProceedResponse, error) {
	rsp, err := c.PostActionsActionIdProceed(ctx, actionId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostActionsActionIdProceedResponse(rsp)
}

// GetCustomersMyBalanceWithResponse request returning *GetCustomersMyBalanceResponse
func (c *ClientWithResponses) GetCustomersMyBalanceWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCustomersMyBalanceResponse, error) {
	rsp, err := c.GetCustomersMyBalance(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCustomersMyBalanceResponse(rsp)
}

// GetCustomersMyInvoicesWithResponse request returning *GetCustomersMyInvoicesResponse
func (c *ClientWithResponses) GetCustomersMyInvoicesWithResponse(ctx context.Context, params *GetCustomersMyInvoicesParams, reqEditors ...RequestEditorFn) (*GetCustomersMyInvoicesResponse, error) {
	rsp, err := c.GetCustomersMyInvoices(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCustomersMyInvoicesResponse(rsp)
}

// GetCustomersMyInvoicesInvoiceIdWithResponse request returning *GetCustomersMyInvoicesInvoiceIdResponse
func (c *ClientWithResponses) GetCustomersMyInvoicesInvoiceIdWithResponse(ctx context.Context, invoiceId int64, reqEditors ...RequestEditorFn) (*GetCustomersMyInvoicesInvoiceIdResponse, error) {
	rsp, err := c.GetCustomersMyInvoicesInvoiceId(ctx, invoiceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCustomersMyInvoicesInvoiceIdResponse(rsp)
}

// GetCustomersMyUnpaidPaymentFailedInvoicesWithResponse request returning *GetCustomersMyUnpaidPaymentFailedInvoicesResponse
func (c *ClientWithResponses) GetCustomersMyUnpaidPaymentFailedInvoicesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetCustomersMyUnpaidPaymentFailedInvoicesResponse, error) {
	rsp, err := c.GetCustomersMyUnpaidPaymentFailedInvoices(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetCustomersMyUnpaidPaymentFailedInvoicesResponse(rsp)
}

// GetDataUsagesCurrentWithResponse request returning *GetDataUsagesCurrentResponse
func (c *ClientWithResponses) GetDataUsagesCurrentWithResponse(ctx context.Context, params *GetDataUsagesCurrentParams, reqEditors ...RequestEditorFn) (*GetDataUsagesCurrentResponse, error) {
	rsp, err := c.GetDataUsagesCurrent(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDataUsagesCurrentResponse(rsp)
}

// GetDataUsagesServerIdCurrentWithResponse request returning *GetDataUsagesServerIdCurrentResponse
func (c *ClientWithResponses) GetDataUsagesServerIdCurrentWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetDataUsagesServerIdCurrentResponse, error) {
	rsp, err := c.GetDataUsagesServerIdCurrent(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDataUsagesServerIdCurrentResponse(rsp)
}

// GetDomainsWithResponse request returning *GetDomainsResponse
func (c *ClientWithResponses) GetDomainsWithResponse(ctx context.Context, params *GetDomainsParams, reqEditors ...RequestEditorFn) (*GetDomainsResponse, error) {
	rsp, err := c.GetDomains(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDomainsResponse(rsp)
}

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

func (c *ClientWithResponses) PostDomainsWithResponse(ctx context.Context, body PostDomainsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsResponse, error) {
	rsp, err := c.PostDomains(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostDomainsResponse(rsp)
}

// GetDomainsNameserversWithResponse request returning *GetDomainsNameserversResponse
func (c *ClientWithResponses) GetDomainsNameserversWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDomainsNameserversResponse, error) {
	rsp, err := c.GetDomainsNameservers(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDomainsNameserversResponse(rsp)
}

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

func (c *ClientWithResponses) PostDomainsRefreshNameserverCacheWithResponse(ctx context.Context, body PostDomainsRefreshNameserverCacheJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsRefreshNameserverCacheResponse, error) {
	rsp, err := c.PostDomainsRefreshNameserverCache(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostDomainsRefreshNameserverCacheResponse(rsp)
}

// DeleteDomainsDomainNameWithResponse request returning *DeleteDomainsDomainNameResponse
func (c *ClientWithResponses) DeleteDomainsDomainNameWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*DeleteDomainsDomainNameResponse, error) {
	rsp, err := c.DeleteDomainsDomainName(ctx, domainName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDomainsDomainNameResponse(rsp)
}

// GetDomainsDomainNameWithResponse request returning *GetDomainsDomainNameResponse
func (c *ClientWithResponses) GetDomainsDomainNameWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameResponse, error) {
	rsp, err := c.GetDomainsDomainName(ctx, domainName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDomainsDomainNameResponse(rsp)
}

// GetDomainsDomainNameRecordsWithResponse request returning *GetDomainsDomainNameRecordsResponse
func (c *ClientWithResponses) GetDomainsDomainNameRecordsWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, params *GetDomainsDomainNameRecordsParams, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameRecordsResponse, error) {
	rsp, err := c.GetDomainsDomainNameRecords(ctx, domainName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDomainsDomainNameRecordsResponse(rsp)
}

// PostDomainsDomainNameRecordsWithBodyWithResponse request with arbitrary body returning *PostDomainsDomainNameRecordsResponse
func (c *ClientWithResponses) PostDomainsDomainNameRecordsWithBodyWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostDomainsDomainNameRecordsResponse, error) {
	rsp, err := c.PostDomainsDomainNameRecordsWithBody(ctx, domainName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostDomainsDomainNameRecordsResponse(rsp)
}

func (c *ClientWithResponses) PostDomainsDomainNameRecordsWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, body PostDomainsDomainNameRecordsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostDomainsDomainNameRecordsResponse, error) {
	rsp, err := c.PostDomainsDomainNameRecords(ctx, domainName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostDomainsDomainNameRecordsResponse(rsp)
}

// DeleteDomainsDomainNameRecordsRecordIdWithResponse request returning *DeleteDomainsDomainNameRecordsRecordIdResponse
func (c *ClientWithResponses) DeleteDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, reqEditors ...RequestEditorFn) (*DeleteDomainsDomainNameRecordsRecordIdResponse, error) {
	rsp, err := c.DeleteDomainsDomainNameRecordsRecordId(ctx, domainName, recordId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteDomainsDomainNameRecordsRecordIdResponse(rsp)
}

// GetDomainsDomainNameRecordsRecordIdWithResponse request returning *GetDomainsDomainNameRecordsRecordIdResponse
func (c *ClientWithResponses) GetDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, reqEditors ...RequestEditorFn) (*GetDomainsDomainNameRecordsRecordIdResponse, error) {
	rsp, err := c.GetDomainsDomainNameRecordsRecordId(ctx, domainName, recordId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDomainsDomainNameRecordsRecordIdResponse(rsp)
}

// PutDomainsDomainNameRecordsRecordIdWithBodyWithResponse request with arbitrary body returning *PutDomainsDomainNameRecordsRecordIdResponse
func (c *ClientWithResponses) PutDomainsDomainNameRecordsRecordIdWithBodyWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutDomainsDomainNameRecordsRecordIdResponse, error) {
	rsp, err := c.PutDomainsDomainNameRecordsRecordIdWithBody(ctx, domainName, recordId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutDomainsDomainNameRecordsRecordIdResponse(rsp)
}

func (c *ClientWithResponses) PutDomainsDomainNameRecordsRecordIdWithResponse(ctx context.Context, domainName struct {
	union json.RawMessage
}, recordId int64, body PutDomainsDomainNameRecordsRecordIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutDomainsDomainNameRecordsRecordIdResponse, error) {
	rsp, err := c.PutDomainsDomainNameRecordsRecordId(ctx, domainName, recordId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutDomainsDomainNameRecordsRecordIdResponse(rsp)
}

// GetImagesWithResponse request returning *GetImagesResponse
func (c *ClientWithResponses) GetImagesWithResponse(ctx context.Context, params *GetImagesParams, reqEditors ...RequestEditorFn) (*GetImagesResponse, error) {
	rsp, err := c.GetImages(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetImagesResponse(rsp)
}

// GetImagesImageIdOrSlugWithResponse request returning *GetImagesImageIdOrSlugResponse
func (c *ClientWithResponses) GetImagesImageIdOrSlugWithResponse(ctx context.Context, imageIdOrSlug struct {
	union json.RawMessage
}, reqEditors ...RequestEditorFn) (*GetImagesImageIdOrSlugResponse, error) {
	rsp, err := c.GetImagesImageIdOrSlug(ctx, imageIdOrSlug, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetImagesImageIdOrSlugResponse(rsp)
}

// GetImagesImageIdDownloadWithResponse request returning *GetImagesImageIdDownloadResponse
func (c *ClientWithResponses) GetImagesImageIdDownloadWithResponse(ctx context.Context, imageId int64, reqEditors ...RequestEditorFn) (*GetImagesImageIdDownloadResponse, error) {
	rsp, err := c.GetImagesImageIdDownload(ctx, imageId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetImagesImageIdDownloadResponse(rsp)
}

// GetLoadBalancersWithResponse request returning *GetLoadBalancersResponse
func (c *ClientWithResponses) GetLoadBalancersWithResponse(ctx context.Context, params *GetLoadBalancersParams, reqEditors ...RequestEditorFn) (*GetLoadBalancersResponse, error) {
	rsp, err := c.GetLoadBalancers(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetLoadBalancersResponse(rsp)
}

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

func (c *ClientWithResponses) PostLoadBalancersWithResponse(ctx context.Context, body PostLoadBalancersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersResponse, error) {
	rsp, err := c.PostLoadBalancers(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostLoadBalancersResponse(rsp)
}

// GetLoadBalancersAvailabilityWithResponse request returning *GetLoadBalancersAvailabilityResponse
func (c *ClientWithResponses) GetLoadBalancersAvailabilityWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetLoadBalancersAvailabilityResponse, error) {
	rsp, err := c.GetLoadBalancersAvailability(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetLoadBalancersAvailabilityResponse(rsp)
}

// DeleteLoadBalancersLoadBalancerIdWithResponse request returning *DeleteLoadBalancersLoadBalancerIdResponse
func (c *ClientWithResponses) DeleteLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdResponse, error) {
	rsp, err := c.DeleteLoadBalancersLoadBalancerId(ctx, loadBalancerId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteLoadBalancersLoadBalancerIdResponse(rsp)
}

// GetLoadBalancersLoadBalancerIdWithResponse request returning *GetLoadBalancersLoadBalancerIdResponse
func (c *ClientWithResponses) GetLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, reqEditors ...RequestEditorFn) (*GetLoadBalancersLoadBalancerIdResponse, error) {
	rsp, err := c.GetLoadBalancersLoadBalancerId(ctx, loadBalancerId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetLoadBalancersLoadBalancerIdResponse(rsp)
}

// PutLoadBalancersLoadBalancerIdWithBodyWithResponse request with arbitrary body returning *PutLoadBalancersLoadBalancerIdResponse
func (c *ClientWithResponses) PutLoadBalancersLoadBalancerIdWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutLoadBalancersLoadBalancerIdResponse, error) {
	rsp, err := c.PutLoadBalancersLoadBalancerIdWithBody(ctx, loadBalancerId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutLoadBalancersLoadBalancerIdResponse(rsp)
}

func (c *ClientWithResponses) PutLoadBalancersLoadBalancerIdWithResponse(ctx context.Context, loadBalancerId int64, body PutLoadBalancersLoadBalancerIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutLoadBalancersLoadBalancerIdResponse, error) {
	rsp, err := c.PutLoadBalancersLoadBalancerId(ctx, loadBalancerId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutLoadBalancersLoadBalancerIdResponse(rsp)
}

// DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse request with arbitrary body returning *DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse
func (c *ClientWithResponses) DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse, error) {
	rsp, err := c.DeleteLoadBalancersLoadBalancerIdForwardingRulesWithBody(ctx, loadBalancerId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteLoadBalancersLoadBalancerIdForwardingRulesResponse(rsp)
}

func (c *ClientWithResponses) DeleteLoadBalancersLoadBalancerIdForwardingRulesWithResponse(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdForwardingRulesResponse, error) {
	rsp, err := c.DeleteLoadBalancersLoadBalancerIdForwardingRules(ctx, loadBalancerId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteLoadBalancersLoadBalancerIdForwardingRulesResponse(rsp)
}

// PostLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse request with arbitrary body returning *PostLoadBalancersLoadBalancerIdForwardingRulesResponse
func (c *ClientWithResponses) PostLoadBalancersLoadBalancerIdForwardingRulesWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdForwardingRulesResponse, error) {
	rsp, err := c.PostLoadBalancersLoadBalancerIdForwardingRulesWithBody(ctx, loadBalancerId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostLoadBalancersLoadBalancerIdForwardingRulesResponse(rsp)
}

func (c *ClientWithResponses) PostLoadBalancersLoadBalancerIdForwardingRulesWithResponse(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdForwardingRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdForwardingRulesResponse, error) {
	rsp, err := c.PostLoadBalancersLoadBalancerIdForwardingRules(ctx, loadBalancerId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostLoadBalancersLoadBalancerIdForwardingRulesResponse(rsp)
}

// DeleteLoadBalancersLoadBalancerIdServersWithBodyWithResponse request with arbitrary body returning *DeleteLoadBalancersLoadBalancerIdServersResponse
func (c *ClientWithResponses) DeleteLoadBalancersLoadBalancerIdServersWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdServersResponse, error) {
	rsp, err := c.DeleteLoadBalancersLoadBalancerIdServersWithBody(ctx, loadBalancerId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteLoadBalancersLoadBalancerIdServersResponse(rsp)
}

func (c *ClientWithResponses) DeleteLoadBalancersLoadBalancerIdServersWithResponse(ctx context.Context, loadBalancerId int64, body DeleteLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*DeleteLoadBalancersLoadBalancerIdServersResponse, error) {
	rsp, err := c.DeleteLoadBalancersLoadBalancerIdServers(ctx, loadBalancerId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteLoadBalancersLoadBalancerIdServersResponse(rsp)
}

// PostLoadBalancersLoadBalancerIdServersWithBodyWithResponse request with arbitrary body returning *PostLoadBalancersLoadBalancerIdServersResponse
func (c *ClientWithResponses) PostLoadBalancersLoadBalancerIdServersWithBodyWithResponse(ctx context.Context, loadBalancerId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdServersResponse, error) {
	rsp, err := c.PostLoadBalancersLoadBalancerIdServersWithBody(ctx, loadBalancerId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostLoadBalancersLoadBalancerIdServersResponse(rsp)
}

func (c *ClientWithResponses) PostLoadBalancersLoadBalancerIdServersWithResponse(ctx context.Context, loadBalancerId int64, body PostLoadBalancersLoadBalancerIdServersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostLoadBalancersLoadBalancerIdServersResponse, error) {
	rsp, err := c.PostLoadBalancersLoadBalancerIdServers(ctx, loadBalancerId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostLoadBalancersLoadBalancerIdServersResponse(rsp)
}

// GetRegionsWithResponse request returning *GetRegionsResponse
func (c *ClientWithResponses) GetRegionsWithResponse(ctx context.Context, params *GetRegionsParams, reqEditors ...RequestEditorFn) (*GetRegionsResponse, error) {
	rsp, err := c.GetRegions(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetRegionsResponse(rsp)
}

// GetReverseNamesIpv6WithResponse request returning *GetReverseNamesIpv6Response
func (c *ClientWithResponses) GetReverseNamesIpv6WithResponse(ctx context.Context, params *GetReverseNamesIpv6Params, reqEditors ...RequestEditorFn) (*GetReverseNamesIpv6Response, error) {
	rsp, err := c.GetReverseNamesIpv6(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetReverseNamesIpv6Response(rsp)
}

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

func (c *ClientWithResponses) PostReverseNamesIpv6WithResponse(ctx context.Context, body PostReverseNamesIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostReverseNamesIpv6Response, error) {
	rsp, err := c.PostReverseNamesIpv6(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostReverseNamesIpv6Response(rsp)
}

// GetSamplesetsServerIdWithResponse request returning *GetSamplesetsServerIdResponse
func (c *ClientWithResponses) GetSamplesetsServerIdWithResponse(ctx context.Context, serverId int64, params *GetSamplesetsServerIdParams, reqEditors ...RequestEditorFn) (*GetSamplesetsServerIdResponse, error) {
	rsp, err := c.GetSamplesetsServerId(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSamplesetsServerIdResponse(rsp)
}

// GetSamplesetsServerIdLatestWithResponse request returning *GetSamplesetsServerIdLatestResponse
func (c *ClientWithResponses) GetSamplesetsServerIdLatestWithResponse(ctx context.Context, serverId int64, params *GetSamplesetsServerIdLatestParams, reqEditors ...RequestEditorFn) (*GetSamplesetsServerIdLatestResponse, error) {
	rsp, err := c.GetSamplesetsServerIdLatest(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSamplesetsServerIdLatestResponse(rsp)
}

// GetServersWithResponse request returning *GetServersResponse
func (c *ClientWithResponses) GetServersWithResponse(ctx context.Context, params *GetServersParams, reqEditors ...RequestEditorFn) (*GetServersResponse, error) {
	rsp, err := c.GetServers(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersResponse(rsp)
}

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

func (c *ClientWithResponses) PostServersWithResponse(ctx context.Context, body PostServersJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersResponse, error) {
	rsp, err := c.PostServers(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersResponse(rsp)
}

// GetServersThresholdAlertsWithResponse request returning *GetServersThresholdAlertsResponse
func (c *ClientWithResponses) GetServersThresholdAlertsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetServersThresholdAlertsResponse, error) {
	rsp, err := c.GetServersThresholdAlerts(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersThresholdAlertsResponse(rsp)
}

// DeleteServersServerIdWithResponse request returning *DeleteServersServerIdResponse
func (c *ClientWithResponses) DeleteServersServerIdWithResponse(ctx context.Context, serverId int64, params *DeleteServersServerIdParams, reqEditors ...RequestEditorFn) (*DeleteServersServerIdResponse, error) {
	rsp, err := c.DeleteServersServerId(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteServersServerIdResponse(rsp)
}

// GetServersServerIdWithResponse request returning *GetServersServerIdResponse
func (c *ClientWithResponses) GetServersServerIdWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdResponse, error) {
	rsp, err := c.GetServersServerId(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdResponse(rsp)
}

// GetServersServerIdActionsWithResponse request returning *GetServersServerIdActionsResponse
func (c *ClientWithResponses) GetServersServerIdActionsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdActionsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdActionsResponse, error) {
	rsp, err := c.GetServersServerIdActions(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdActionsResponse(rsp)
}

// PostServersServerIdActionsWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsResponse
func (c *ClientWithResponses) PostServersServerIdActionsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResponse, error) {
	rsp, err := c.PostServersServerIdActionsWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResponse, error) {
	rsp, err := c.PostServersServerIdActions(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResponse(rsp)
}

// PostServersServerIdActionsAddDiskWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsAddDiskResponse
func (c *ClientWithResponses) PostServersServerIdActionsAddDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAddDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsAddDiskWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsAddDiskResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsAddDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsAddDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAddDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsAddDisk(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsAddDiskResponse(rsp)
}

// PostServersServerIdActionsAttachBackupWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsAttachBackupResponse
func (c *ClientWithResponses) PostServersServerIdActionsAttachBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAttachBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsAttachBackupWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsAttachBackupResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsAttachBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsAttachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsAttachBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsAttachBackup(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsAttachBackupResponse(rsp)
}

// PostServersServerIdActionsChangeAdvancedFeaturesWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeAdvancedFeaturesResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeAdvancedFeaturesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFeaturesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeAdvancedFeaturesWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeAdvancedFeaturesResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeAdvancedFeaturesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFeaturesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFeaturesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeAdvancedFeatures(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeAdvancedFeaturesResponse(rsp)
}

// PostServersServerIdActionsChangeAdvancedFirewallRulesWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeAdvancedFirewallRulesResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeAdvancedFirewallRulesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFirewallRulesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeAdvancedFirewallRulesWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeAdvancedFirewallRulesResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeAdvancedFirewallRulesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeAdvancedFirewallRulesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeAdvancedFirewallRulesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeAdvancedFirewallRules(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeAdvancedFirewallRulesResponse(rsp)
}

// PostServersServerIdActionsChangeBackupScheduleWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeBackupScheduleResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeBackupScheduleWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeBackupScheduleResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeBackupScheduleWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeBackupScheduleResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeBackupScheduleWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeBackupScheduleJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeBackupScheduleResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeBackupSchedule(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeBackupScheduleResponse(rsp)
}

// PostServersServerIdActionsChangeIpv6WithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeIpv6Response
func (c *ClientWithResponses) PostServersServerIdActionsChangeIpv6WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6Response, error) {
	rsp, err := c.PostServersServerIdActionsChangeIpv6WithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeIpv6Response(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeIpv6WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6Response, error) {
	rsp, err := c.PostServersServerIdActionsChangeIpv6(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeIpv6Response(rsp)
}

// PostServersServerIdActionsChangeIpv6ReverseNameserversWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeIpv6ReverseNameserversResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeIpv6ReverseNameserversWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6ReverseNameserversResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeIpv6ReverseNameserversWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeIpv6ReverseNameserversResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeIpv6ReverseNameserversWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeIpv6ReverseNameserversJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeIpv6ReverseNameserversResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeIpv6ReverseNameservers(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeIpv6ReverseNameserversResponse(rsp)
}

// PostServersServerIdActionsChangeKernelWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeKernelResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeKernelWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeKernelResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeKernelWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeKernelResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeKernelWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeKernelJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeKernelResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeKernel(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeKernelResponse(rsp)
}

// PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeManageOffsiteBackupCopiesWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeManageOffsiteBackupCopiesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeManageOffsiteBackupCopies(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeManageOffsiteBackupCopiesResponse(rsp)
}

// PostServersServerIdActionsChangeNetworkWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeNetworkResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeNetworkWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeNetworkResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeNetworkWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeNetworkResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeNetworkWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeNetworkJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeNetworkResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeNetwork(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeNetworkResponse(rsp)
}

// PostServersServerIdActionsChangeOffsiteBackupLocationWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeOffsiteBackupLocationResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeOffsiteBackupLocationWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeOffsiteBackupLocationResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeOffsiteBackupLocationWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeOffsiteBackupLocationResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeOffsiteBackupLocationWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeOffsiteBackupLocationJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeOffsiteBackupLocationResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeOffsiteBackupLocation(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeOffsiteBackupLocationResponse(rsp)
}

// PostServersServerIdActionsChangePartnerWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangePartnerResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangePartnerWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePartnerResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangePartnerWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangePartnerResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangePartnerWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePartnerJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePartnerResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangePartner(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangePartnerResponse(rsp)
}

// PostServersServerIdActionsChangePortBlockingWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangePortBlockingResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangePortBlockingWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePortBlockingResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangePortBlockingWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangePortBlockingResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangePortBlockingWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangePortBlockingJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangePortBlockingResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangePortBlocking(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangePortBlockingResponse(rsp)
}

// PostServersServerIdActionsChangeRegionWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeRegionResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeRegionWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeRegionResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeRegionWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeRegionResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeRegionWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeRegionJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeRegionResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeRegion(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeRegionResponse(rsp)
}

// PostServersServerIdActionsChangeReverseNameWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeReverseNameResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeReverseNameWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeReverseNameResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeReverseNameWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeReverseNameResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeReverseNameWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeReverseNameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeReverseNameResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeReverseName(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeReverseNameResponse(rsp)
}

// PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeSeparatePrivateNetworkInterface(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeSeparatePrivateNetworkInterfaceResponse(rsp)
}

// PostServersServerIdActionsChangeSourceAndDestinationCheckWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeSourceAndDestinationCheckResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeSourceAndDestinationCheckWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSourceAndDestinationCheckResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeSourceAndDestinationCheckWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeSourceAndDestinationCheckResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeSourceAndDestinationCheckWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeSourceAndDestinationCheckJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeSourceAndDestinationCheckResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeSourceAndDestinationCheck(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeSourceAndDestinationCheckResponse(rsp)
}

// PostServersServerIdActionsChangeThresholdAlertsWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeThresholdAlertsResponse
func (c *ClientWithResponses) PostServersServerIdActionsChangeThresholdAlertsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeThresholdAlertsResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeThresholdAlertsWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeThresholdAlertsResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeThresholdAlertsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeThresholdAlertsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeThresholdAlertsResponse, error) {
	rsp, err := c.PostServersServerIdActionsChangeThresholdAlerts(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeThresholdAlertsResponse(rsp)
}

// PostServersServerIdActionsChangeVpcIpv4WithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsChangeVpcIpv4Response
func (c *ClientWithResponses) PostServersServerIdActionsChangeVpcIpv4WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeVpcIpv4Response, error) {
	rsp, err := c.PostServersServerIdActionsChangeVpcIpv4WithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeVpcIpv4Response(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsChangeVpcIpv4WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsChangeVpcIpv4JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsChangeVpcIpv4Response, error) {
	rsp, err := c.PostServersServerIdActionsChangeVpcIpv4(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsChangeVpcIpv4Response(rsp)
}

// PostServersServerIdActionsCloneUsingBackupWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsCloneUsingBackupResponse
func (c *ClientWithResponses) PostServersServerIdActionsCloneUsingBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsCloneUsingBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsCloneUsingBackupWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsCloneUsingBackupResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsCloneUsingBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsCloneUsingBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsCloneUsingBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsCloneUsingBackup(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsCloneUsingBackupResponse(rsp)
}

// PostServersServerIdActionsDeleteDiskWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsDeleteDiskResponse
func (c *ClientWithResponses) PostServersServerIdActionsDeleteDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDeleteDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsDeleteDiskWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDeleteDiskResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsDeleteDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDeleteDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDeleteDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsDeleteDisk(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDeleteDiskResponse(rsp)
}

// PostServersServerIdActionsDetachBackupWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsDetachBackupResponse
func (c *ClientWithResponses) PostServersServerIdActionsDetachBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDetachBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsDetachBackupWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDetachBackupResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsDetachBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDetachBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDetachBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsDetachBackup(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDetachBackupResponse(rsp)
}

// PostServersServerIdActionsDisableBackupsWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsDisableBackupsResponse
func (c *ClientWithResponses) PostServersServerIdActionsDisableBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableBackupsResponse, error) {
	rsp, err := c.PostServersServerIdActionsDisableBackupsWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDisableBackupsResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsDisableBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableBackupsResponse, error) {
	rsp, err := c.PostServersServerIdActionsDisableBackups(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDisableBackupsResponse(rsp)
}

// PostServersServerIdActionsDisableSelinuxWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsDisableSelinuxResponse
func (c *ClientWithResponses) PostServersServerIdActionsDisableSelinuxWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableSelinuxResponse, error) {
	rsp, err := c.PostServersServerIdActionsDisableSelinuxWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDisableSelinuxResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsDisableSelinuxWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsDisableSelinuxJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsDisableSelinuxResponse, error) {
	rsp, err := c.PostServersServerIdActionsDisableSelinux(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsDisableSelinuxResponse(rsp)
}

// PostServersServerIdActionsEnableBackupsWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsEnableBackupsResponse
func (c *ClientWithResponses) PostServersServerIdActionsEnableBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableBackupsResponse, error) {
	rsp, err := c.PostServersServerIdActionsEnableBackupsWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsEnableBackupsResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsEnableBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableBackupsResponse, error) {
	rsp, err := c.PostServersServerIdActionsEnableBackups(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsEnableBackupsResponse(rsp)
}

// PostServersServerIdActionsEnableIpv6WithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsEnableIpv6Response
func (c *ClientWithResponses) PostServersServerIdActionsEnableIpv6WithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableIpv6Response, error) {
	rsp, err := c.PostServersServerIdActionsEnableIpv6WithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsEnableIpv6Response(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsEnableIpv6WithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsEnableIpv6JSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsEnableIpv6Response, error) {
	rsp, err := c.PostServersServerIdActionsEnableIpv6(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsEnableIpv6Response(rsp)
}

// PostServersServerIdActionsIsRunningWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsIsRunningResponse
func (c *ClientWithResponses) PostServersServerIdActionsIsRunningWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsIsRunningResponse, error) {
	rsp, err := c.PostServersServerIdActionsIsRunningWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsIsRunningResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsIsRunningWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsIsRunningJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsIsRunningResponse, error) {
	rsp, err := c.PostServersServerIdActionsIsRunning(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsIsRunningResponse(rsp)
}

// PostServersServerIdActionsPasswordResetWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsPasswordResetResponse
func (c *ClientWithResponses) PostServersServerIdActionsPasswordResetWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPasswordResetResponse, error) {
	rsp, err := c.PostServersServerIdActionsPasswordResetWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPasswordResetResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsPasswordResetWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPasswordResetJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPasswordResetResponse, error) {
	rsp, err := c.PostServersServerIdActionsPasswordReset(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPasswordResetResponse(rsp)
}

// PostServersServerIdActionsPingWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsPingResponse
func (c *ClientWithResponses) PostServersServerIdActionsPingWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPingResponse, error) {
	rsp, err := c.PostServersServerIdActionsPingWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPingResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsPingWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPingJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPingResponse, error) {
	rsp, err := c.PostServersServerIdActionsPing(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPingResponse(rsp)
}

// PostServersServerIdActionsPowerCycleWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsPowerCycleResponse
func (c *ClientWithResponses) PostServersServerIdActionsPowerCycleWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerCycleResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerCycleWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerCycleResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsPowerCycleWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerCycleJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerCycleResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerCycle(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerCycleResponse(rsp)
}

// PostServersServerIdActionsPowerOffWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsPowerOffResponse
func (c *ClientWithResponses) PostServersServerIdActionsPowerOffWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOffResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerOffWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerOffResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsPowerOffWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOffJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOffResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerOff(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerOffResponse(rsp)
}

// PostServersServerIdActionsPowerOnWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsPowerOnResponse
func (c *ClientWithResponses) PostServersServerIdActionsPowerOnWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOnResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerOnWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerOnResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsPowerOnWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsPowerOnJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsPowerOnResponse, error) {
	rsp, err := c.PostServersServerIdActionsPowerOn(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsPowerOnResponse(rsp)
}

// PostServersServerIdActionsRebootWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsRebootResponse
func (c *ClientWithResponses) PostServersServerIdActionsRebootWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebootResponse, error) {
	rsp, err := c.PostServersServerIdActionsRebootWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRebootResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsRebootWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRebootJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebootResponse, error) {
	rsp, err := c.PostServersServerIdActionsReboot(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRebootResponse(rsp)
}

// PostServersServerIdActionsRebuildWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsRebuildResponse
func (c *ClientWithResponses) PostServersServerIdActionsRebuildWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebuildResponse, error) {
	rsp, err := c.PostServersServerIdActionsRebuildWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRebuildResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsRebuildWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRebuildJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRebuildResponse, error) {
	rsp, err := c.PostServersServerIdActionsRebuild(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRebuildResponse(rsp)
}

// PostServersServerIdActionsRenameWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsRenameResponse
func (c *ClientWithResponses) PostServersServerIdActionsRenameWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRenameResponse, error) {
	rsp, err := c.PostServersServerIdActionsRenameWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRenameResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsRenameWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRenameResponse, error) {
	rsp, err := c.PostServersServerIdActionsRename(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRenameResponse(rsp)
}

// PostServersServerIdActionsResizeWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsResizeResponse
func (c *ClientWithResponses) PostServersServerIdActionsResizeWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeResponse, error) {
	rsp, err := c.PostServersServerIdActionsResizeWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResizeResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsResizeWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeResponse, error) {
	rsp, err := c.PostServersServerIdActionsResize(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResizeResponse(rsp)
}

// PostServersServerIdActionsResizeDiskWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsResizeDiskResponse
func (c *ClientWithResponses) PostServersServerIdActionsResizeDiskWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsResizeDiskWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResizeDiskResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsResizeDiskWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsResizeDiskJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsResizeDiskResponse, error) {
	rsp, err := c.PostServersServerIdActionsResizeDisk(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsResizeDiskResponse(rsp)
}

// PostServersServerIdActionsRestoreWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsRestoreResponse
func (c *ClientWithResponses) PostServersServerIdActionsRestoreWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRestoreResponse, error) {
	rsp, err := c.PostServersServerIdActionsRestoreWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRestoreResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsRestoreWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsRestoreJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsRestoreResponse, error) {
	rsp, err := c.PostServersServerIdActionsRestore(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsRestoreResponse(rsp)
}

// PostServersServerIdActionsShutdownWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsShutdownResponse
func (c *ClientWithResponses) PostServersServerIdActionsShutdownWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsShutdownResponse, error) {
	rsp, err := c.PostServersServerIdActionsShutdownWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsShutdownResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsShutdownWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsShutdownJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsShutdownResponse, error) {
	rsp, err := c.PostServersServerIdActionsShutdown(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsShutdownResponse(rsp)
}

// PostServersServerIdActionsTakeBackupWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsTakeBackupResponse
func (c *ClientWithResponses) PostServersServerIdActionsTakeBackupWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsTakeBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsTakeBackupWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsTakeBackupResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsTakeBackupWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsTakeBackupJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsTakeBackupResponse, error) {
	rsp, err := c.PostServersServerIdActionsTakeBackup(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsTakeBackupResponse(rsp)
}

// PostServersServerIdActionsUncancelWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsUncancelResponse
func (c *ClientWithResponses) PostServersServerIdActionsUncancelWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUncancelResponse, error) {
	rsp, err := c.PostServersServerIdActionsUncancelWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsUncancelResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsUncancelWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsUncancelJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUncancelResponse, error) {
	rsp, err := c.PostServersServerIdActionsUncancel(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsUncancelResponse(rsp)
}

// PostServersServerIdActionsUptimeWithBodyWithResponse request with arbitrary body returning *PostServersServerIdActionsUptimeResponse
func (c *ClientWithResponses) PostServersServerIdActionsUptimeWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUptimeResponse, error) {
	rsp, err := c.PostServersServerIdActionsUptimeWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsUptimeResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdActionsUptimeWithResponse(ctx context.Context, serverId int64, body PostServersServerIdActionsUptimeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdActionsUptimeResponse, error) {
	rsp, err := c.PostServersServerIdActionsUptime(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdActionsUptimeResponse(rsp)
}

// GetServersServerIdActionsActionIdWithResponse request returning *GetServersServerIdActionsActionIdResponse
func (c *ClientWithResponses) GetServersServerIdActionsActionIdWithResponse(ctx context.Context, serverId int64, actionId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdActionsActionIdResponse, error) {
	rsp, err := c.GetServersServerIdActionsActionId(ctx, serverId, actionId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdActionsActionIdResponse(rsp)
}

// GetServersServerIdAdvancedFirewallRulesWithResponse request returning *GetServersServerIdAdvancedFirewallRulesResponse
func (c *ClientWithResponses) GetServersServerIdAdvancedFirewallRulesWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdAdvancedFirewallRulesResponse, error) {
	rsp, err := c.GetServersServerIdAdvancedFirewallRules(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdAdvancedFirewallRulesResponse(rsp)
}

// GetServersServerIdAvailableAdvancedFeaturesWithResponse request returning *GetServersServerIdAvailableAdvancedFeaturesResponse
func (c *ClientWithResponses) GetServersServerIdAvailableAdvancedFeaturesWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdAvailableAdvancedFeaturesResponse, error) {
	rsp, err := c.GetServersServerIdAvailableAdvancedFeatures(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdAvailableAdvancedFeaturesResponse(rsp)
}

// GetServersServerIdBackupsWithResponse request returning *GetServersServerIdBackupsResponse
func (c *ClientWithResponses) GetServersServerIdBackupsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdBackupsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdBackupsResponse, error) {
	rsp, err := c.GetServersServerIdBackups(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdBackupsResponse(rsp)
}

// PostServersServerIdBackupsWithBodyWithResponse request with arbitrary body returning *PostServersServerIdBackupsResponse
func (c *ClientWithResponses) PostServersServerIdBackupsWithBodyWithResponse(ctx context.Context, serverId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostServersServerIdBackupsResponse, error) {
	rsp, err := c.PostServersServerIdBackupsWithBody(ctx, serverId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdBackupsResponse(rsp)
}

func (c *ClientWithResponses) PostServersServerIdBackupsWithResponse(ctx context.Context, serverId int64, body PostServersServerIdBackupsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostServersServerIdBackupsResponse, error) {
	rsp, err := c.PostServersServerIdBackups(ctx, serverId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostServersServerIdBackupsResponse(rsp)
}

// GetServersServerIdConsoleWithResponse request returning *GetServersServerIdConsoleResponse
func (c *ClientWithResponses) GetServersServerIdConsoleWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdConsoleResponse, error) {
	rsp, err := c.GetServersServerIdConsole(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdConsoleResponse(rsp)
}

// GetServersServerIdKernelsWithResponse request returning *GetServersServerIdKernelsResponse
func (c *ClientWithResponses) GetServersServerIdKernelsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdKernelsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdKernelsResponse, error) {
	rsp, err := c.GetServersServerIdKernels(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdKernelsResponse(rsp)
}

// GetServersServerIdSnapshotsWithResponse request returning *GetServersServerIdSnapshotsResponse
func (c *ClientWithResponses) GetServersServerIdSnapshotsWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdSnapshotsParams, reqEditors ...RequestEditorFn) (*GetServersServerIdSnapshotsResponse, error) {
	rsp, err := c.GetServersServerIdSnapshots(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdSnapshotsResponse(rsp)
}

// GetServersServerIdSoftwareWithResponse request returning *GetServersServerIdSoftwareResponse
func (c *ClientWithResponses) GetServersServerIdSoftwareWithResponse(ctx context.Context, serverId int64, params *GetServersServerIdSoftwareParams, reqEditors ...RequestEditorFn) (*GetServersServerIdSoftwareResponse, error) {
	rsp, err := c.GetServersServerIdSoftware(ctx, serverId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdSoftwareResponse(rsp)
}

// GetServersServerIdThresholdAlertsWithResponse request returning *GetServersServerIdThresholdAlertsResponse
func (c *ClientWithResponses) GetServersServerIdThresholdAlertsWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdThresholdAlertsResponse, error) {
	rsp, err := c.GetServersServerIdThresholdAlerts(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdThresholdAlertsResponse(rsp)
}

// GetServersServerIdUserDataWithResponse request returning *GetServersServerIdUserDataResponse
func (c *ClientWithResponses) GetServersServerIdUserDataWithResponse(ctx context.Context, serverId int64, reqEditors ...RequestEditorFn) (*GetServersServerIdUserDataResponse, error) {
	rsp, err := c.GetServersServerIdUserData(ctx, serverId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetServersServerIdUserDataResponse(rsp)
}

// GetSizesWithResponse request returning *GetSizesResponse
func (c *ClientWithResponses) GetSizesWithResponse(ctx context.Context, params *GetSizesParams, reqEditors ...RequestEditorFn) (*GetSizesResponse, error) {
	rsp, err := c.GetSizes(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSizesResponse(rsp)
}

// GetSoftwareWithResponse request returning *GetSoftwareResponse
func (c *ClientWithResponses) GetSoftwareWithResponse(ctx context.Context, params *GetSoftwareParams, reqEditors ...RequestEditorFn) (*GetSoftwareResponse, error) {
	rsp, err := c.GetSoftware(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSoftwareResponse(rsp)
}

// GetSoftwareOperatingSystemOperatingSystemIdOrSlugWithResponse request returning *GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse
func (c *ClientWithResponses) GetSoftwareOperatingSystemOperatingSystemIdOrSlugWithResponse(ctx context.Context, operatingSystemIdOrSlug struct {
	union json.RawMessage
}, params *GetSoftwareOperatingSystemOperatingSystemIdOrSlugParams, reqEditors ...RequestEditorFn) (*GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse, error) {
	rsp, err := c.GetSoftwareOperatingSystemOperatingSystemIdOrSlug(ctx, operatingSystemIdOrSlug, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse(rsp)
}

// GetSoftwareSoftwareIdWithResponse request returning *GetSoftwareSoftwareIdResponse
func (c *ClientWithResponses) GetSoftwareSoftwareIdWithResponse(ctx context.Context, softwareId int64, reqEditors ...RequestEditorFn) (*GetSoftwareSoftwareIdResponse, error) {
	rsp, err := c.GetSoftwareSoftwareId(ctx, softwareId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetSoftwareSoftwareIdResponse(rsp)
}

// GetVpcsWithResponse request returning *GetVpcsResponse
func (c *ClientWithResponses) GetVpcsWithResponse(ctx context.Context, params *GetVpcsParams, reqEditors ...RequestEditorFn) (*GetVpcsResponse, error) {
	rsp, err := c.GetVpcs(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetVpcsResponse(rsp)
}

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

func (c *ClientWithResponses) PostVpcsWithResponse(ctx context.Context, body PostVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostVpcsResponse, error) {
	rsp, err := c.PostVpcs(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostVpcsResponse(rsp)
}

// DeleteVpcsVpcIdWithResponse request returning *DeleteVpcsVpcIdResponse
func (c *ClientWithResponses) DeleteVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*DeleteVpcsVpcIdResponse, error) {
	rsp, err := c.DeleteVpcsVpcId(ctx, vpcId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteVpcsVpcIdResponse(rsp)
}

// GetVpcsVpcIdWithResponse request returning *GetVpcsVpcIdResponse
func (c *ClientWithResponses) GetVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, reqEditors ...RequestEditorFn) (*GetVpcsVpcIdResponse, error) {
	rsp, err := c.GetVpcsVpcId(ctx, vpcId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetVpcsVpcIdResponse(rsp)
}

// PatchVpcsVpcIdWithBodyWithResponse request with arbitrary body returning *PatchVpcsVpcIdResponse
func (c *ClientWithResponses) PatchVpcsVpcIdWithBodyWithResponse(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PatchVpcsVpcIdResponse, error) {
	rsp, err := c.PatchVpcsVpcIdWithBody(ctx, vpcId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePatchVpcsVpcIdResponse(rsp)
}

func (c *ClientWithResponses) PatchVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, body PatchVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PatchVpcsVpcIdResponse, error) {
	rsp, err := c.PatchVpcsVpcId(ctx, vpcId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePatchVpcsVpcIdResponse(rsp)
}

// PutVpcsVpcIdWithBodyWithResponse request with arbitrary body returning *PutVpcsVpcIdResponse
func (c *ClientWithResponses) PutVpcsVpcIdWithBodyWithResponse(ctx context.Context, vpcId int64, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutVpcsVpcIdResponse, error) {
	rsp, err := c.PutVpcsVpcIdWithBody(ctx, vpcId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutVpcsVpcIdResponse(rsp)
}

func (c *ClientWithResponses) PutVpcsVpcIdWithResponse(ctx context.Context, vpcId int64, body PutVpcsVpcIdJSONRequestBody, reqEditors ...RequestEditorFn) (*PutVpcsVpcIdResponse, error) {
	rsp, err := c.PutVpcsVpcId(ctx, vpcId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePutVpcsVpcIdResponse(rsp)
}

// GetVpcsVpcIdMembersWithResponse request returning *GetVpcsVpcIdMembersResponse
func (c *ClientWithResponses) GetVpcsVpcIdMembersWithResponse(ctx context.Context, vpcId int64, params *GetVpcsVpcIdMembersParams, reqEditors ...RequestEditorFn) (*GetVpcsVpcIdMembersResponse, error) {
	rsp, err := c.GetVpcsVpcIdMembers(ctx, vpcId, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetVpcsVpcIdMembersResponse(rsp)
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

	return response, nil
}

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

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

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

	response := &PostServersServerIdActionsEnableBackupsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsEnableIpv6Response parses an HTTP response from a PostServersServerIdActionsEnableIpv6WithResponse call
func ParsePostServersServerIdActionsEnableIpv6Response(rsp *http.Response) (*PostServersServerIdActionsEnableIpv6Response, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsEnableIpv6Response{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsIsRunningResponse parses an HTTP response from a PostServersServerIdActionsIsRunningWithResponse call
func ParsePostServersServerIdActionsIsRunningResponse(rsp *http.Response) (*PostServersServerIdActionsIsRunningResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsIsRunningResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsPasswordResetResponse parses an HTTP response from a PostServersServerIdActionsPasswordResetWithResponse call
func ParsePostServersServerIdActionsPasswordResetResponse(rsp *http.Response) (*PostServersServerIdActionsPasswordResetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsPasswordResetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsPingResponse parses an HTTP response from a PostServersServerIdActionsPingWithResponse call
func ParsePostServersServerIdActionsPingResponse(rsp *http.Response) (*PostServersServerIdActionsPingResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsPingResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsPowerCycleResponse parses an HTTP response from a PostServersServerIdActionsPowerCycleWithResponse call
func ParsePostServersServerIdActionsPowerCycleResponse(rsp *http.Response) (*PostServersServerIdActionsPowerCycleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsPowerCycleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsPowerOffResponse parses an HTTP response from a PostServersServerIdActionsPowerOffWithResponse call
func ParsePostServersServerIdActionsPowerOffResponse(rsp *http.Response) (*PostServersServerIdActionsPowerOffResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsPowerOffResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsPowerOnResponse parses an HTTP response from a PostServersServerIdActionsPowerOnWithResponse call
func ParsePostServersServerIdActionsPowerOnResponse(rsp *http.Response) (*PostServersServerIdActionsPowerOnResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsPowerOnResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsRebootResponse parses an HTTP response from a PostServersServerIdActionsRebootWithResponse call
func ParsePostServersServerIdActionsRebootResponse(rsp *http.Response) (*PostServersServerIdActionsRebootResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsRebootResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsRebuildResponse parses an HTTP response from a PostServersServerIdActionsRebuildWithResponse call
func ParsePostServersServerIdActionsRebuildResponse(rsp *http.Response) (*PostServersServerIdActionsRebuildResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsRebuildResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsRenameResponse parses an HTTP response from a PostServersServerIdActionsRenameWithResponse call
func ParsePostServersServerIdActionsRenameResponse(rsp *http.Response) (*PostServersServerIdActionsRenameResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsRenameResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsResizeResponse parses an HTTP response from a PostServersServerIdActionsResizeWithResponse call
func ParsePostServersServerIdActionsResizeResponse(rsp *http.Response) (*PostServersServerIdActionsResizeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsResizeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsResizeDiskResponse parses an HTTP response from a PostServersServerIdActionsResizeDiskWithResponse call
func ParsePostServersServerIdActionsResizeDiskResponse(rsp *http.Response) (*PostServersServerIdActionsResizeDiskResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsResizeDiskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsRestoreResponse parses an HTTP response from a PostServersServerIdActionsRestoreWithResponse call
func ParsePostServersServerIdActionsRestoreResponse(rsp *http.Response) (*PostServersServerIdActionsRestoreResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsRestoreResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsShutdownResponse parses an HTTP response from a PostServersServerIdActionsShutdownWithResponse call
func ParsePostServersServerIdActionsShutdownResponse(rsp *http.Response) (*PostServersServerIdActionsShutdownResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsShutdownResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsTakeBackupResponse parses an HTTP response from a PostServersServerIdActionsTakeBackupWithResponse call
func ParsePostServersServerIdActionsTakeBackupResponse(rsp *http.Response) (*PostServersServerIdActionsTakeBackupResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsTakeBackupResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsUncancelResponse parses an HTTP response from a PostServersServerIdActionsUncancelWithResponse call
func ParsePostServersServerIdActionsUncancelResponse(rsp *http.Response) (*PostServersServerIdActionsUncancelResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsUncancelResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdActionsUptimeResponse parses an HTTP response from a PostServersServerIdActionsUptimeWithResponse call
func ParsePostServersServerIdActionsUptimeResponse(rsp *http.Response) (*PostServersServerIdActionsUptimeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdActionsUptimeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdActionsActionIdResponse parses an HTTP response from a GetServersServerIdActionsActionIdWithResponse call
func ParseGetServersServerIdActionsActionIdResponse(rsp *http.Response) (*GetServersServerIdActionsActionIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdActionsActionIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdAdvancedFirewallRulesResponse parses an HTTP response from a GetServersServerIdAdvancedFirewallRulesWithResponse call
func ParseGetServersServerIdAdvancedFirewallRulesResponse(rsp *http.Response) (*GetServersServerIdAdvancedFirewallRulesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdAdvancedFirewallRulesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AdvancedFirewallRulesResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdAvailableAdvancedFeaturesResponse parses an HTTP response from a GetServersServerIdAvailableAdvancedFeaturesWithResponse call
func ParseGetServersServerIdAvailableAdvancedFeaturesResponse(rsp *http.Response) (*GetServersServerIdAvailableAdvancedFeaturesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdAvailableAdvancedFeaturesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AvailableAdvancedServerFeaturesResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdBackupsResponse parses an HTTP response from a GetServersServerIdBackupsWithResponse call
func ParseGetServersServerIdBackupsResponse(rsp *http.Response) (*GetServersServerIdBackupsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdBackupsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest BackupsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostServersServerIdBackupsResponse parses an HTTP response from a PostServersServerIdBackupsWithResponse call
func ParsePostServersServerIdBackupsResponse(rsp *http.Response) (*PostServersServerIdBackupsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostServersServerIdBackupsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ActionResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdConsoleResponse parses an HTTP response from a GetServersServerIdConsoleWithResponse call
func ParseGetServersServerIdConsoleResponse(rsp *http.Response) (*GetServersServerIdConsoleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdConsoleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ConsoleResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdKernelsResponse parses an HTTP response from a GetServersServerIdKernelsWithResponse call
func ParseGetServersServerIdKernelsResponse(rsp *http.Response) (*GetServersServerIdKernelsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdKernelsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest KernelsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdSnapshotsResponse parses an HTTP response from a GetServersServerIdSnapshotsWithResponse call
func ParseGetServersServerIdSnapshotsResponse(rsp *http.Response) (*GetServersServerIdSnapshotsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdSnapshotsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SnapshotsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdSoftwareResponse parses an HTTP response from a GetServersServerIdSoftwareWithResponse call
func ParseGetServersServerIdSoftwareResponse(rsp *http.Response) (*GetServersServerIdSoftwareResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdSoftwareResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest LicensedSoftwaresResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdThresholdAlertsResponse parses an HTTP response from a GetServersServerIdThresholdAlertsWithResponse call
func ParseGetServersServerIdThresholdAlertsResponse(rsp *http.Response) (*GetServersServerIdThresholdAlertsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdThresholdAlertsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ThresholdAlertsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetServersServerIdUserDataResponse parses an HTTP response from a GetServersServerIdUserDataWithResponse call
func ParseGetServersServerIdUserDataResponse(rsp *http.Response) (*GetServersServerIdUserDataResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetServersServerIdUserDataResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest UserData
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetSizesResponse parses an HTTP response from a GetSizesWithResponse call
func ParseGetSizesResponse(rsp *http.Response) (*GetSizesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSizesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SizesResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetSoftwareResponse parses an HTTP response from a GetSoftwareWithResponse call
func ParseGetSoftwareResponse(rsp *http.Response) (*GetSoftwareResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSoftwareResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SoftwaresResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse parses an HTTP response from a GetSoftwareOperatingSystemOperatingSystemIdOrSlugWithResponse call
func ParseGetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse(rsp *http.Response) (*GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSoftwareOperatingSystemOperatingSystemIdOrSlugResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SoftwaresResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetSoftwareSoftwareIdResponse parses an HTTP response from a GetSoftwareSoftwareIdWithResponse call
func ParseGetSoftwareSoftwareIdResponse(rsp *http.Response) (*GetSoftwareSoftwareIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetSoftwareSoftwareIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SoftwareResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetVpcsResponse parses an HTTP response from a GetVpcsWithResponse call
func ParseGetVpcsResponse(rsp *http.Response) (*GetVpcsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetVpcsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostVpcsResponse parses an HTTP response from a PostVpcsWithResponse call
func ParsePostVpcsResponse(rsp *http.Response) (*PostVpcsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostVpcsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseDeleteVpcsVpcIdResponse parses an HTTP response from a DeleteVpcsVpcIdWithResponse call
func ParseDeleteVpcsVpcIdResponse(rsp *http.Response) (*DeleteVpcsVpcIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DeleteVpcsVpcIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseGetVpcsVpcIdResponse parses an HTTP response from a GetVpcsVpcIdWithResponse call
func ParseGetVpcsVpcIdResponse(rsp *http.Response) (*GetVpcsVpcIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetVpcsVpcIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePatchVpcsVpcIdResponse parses an HTTP response from a PatchVpcsVpcIdWithResponse call
func ParsePatchVpcsVpcIdResponse(rsp *http.Response) (*PatchVpcsVpcIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PatchVpcsVpcIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePutVpcsVpcIdResponse parses an HTTP response from a PutVpcsVpcIdWithResponse call
func ParsePutVpcsVpcIdResponse(rsp *http.Response) (*PutVpcsVpcIdResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PutVpcsVpcIdResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetVpcsVpcIdMembersResponse parses an HTTP response from a GetVpcsVpcIdMembersWithResponse call
func ParseGetVpcsVpcIdMembersResponse(rsp *http.Response) (*GetVpcsVpcIdMembersResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetVpcsVpcIdMembersResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VpcMembersResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}