client.go

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

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

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

	PostProjectsProjectIdServices(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdServicesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProjectsProjectIdServicesServiceId request
	DeleteProjectsProjectIdServicesServiceId(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdServicesServiceId request
	GetProjectsProjectIdServicesServiceId(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdAttachToVPCWithBody request with any body
	PostProjectsProjectIdServicesServiceIdAttachToVPCWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdAttachToVPC(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdAttachToVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBody request with any body
	PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdDetachFromVPC(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdDetachFromVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdDisablePooler request
	PostProjectsProjectIdServicesServiceIdDisablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdEnablePooler request
	PostProjectsProjectIdServicesServiceIdEnablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdForkServiceWithBody request with any body
	PostProjectsProjectIdServicesServiceIdForkServiceWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdForkService(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdForkServiceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdServicesServiceIdReplicaSets request
	GetProjectsProjectIdServicesServiceIdReplicaSets(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsWithBody request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdReplicaSets(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdReplicaSetsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetId request
	DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetId(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePooler request
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePooler request
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBody request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResize(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBody request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironment(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdResizeWithBody request with any body
	PostProjectsProjectIdServicesServiceIdResizeWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdResize(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBody request with any body
	PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdSetEnvironment(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdSetHAWithBody request with any body
	PostProjectsProjectIdServicesServiceIdSetHAWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdSetHA(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetHAJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBody request with any body
	PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdServicesServiceIdUpdatePassword(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdVpcs request
	GetProjectsProjectIdVpcs(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostProjectsProjectIdVpcs(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProjectsProjectIdVpcsVpcId request
	DeleteProjectsProjectIdVpcsVpcId(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdVpcsVpcId request
	GetProjectsProjectIdVpcsVpcId(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdVpcsVpcIdPeerings request
	GetProjectsProjectIdVpcsVpcIdPeerings(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdVpcsVpcIdPeeringsWithBody request with any body
	PostProjectsProjectIdVpcsVpcIdPeeringsWithBody(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdVpcsVpcIdPeerings(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdPeeringsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringId request
	DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetProjectsProjectIdVpcsVpcIdPeeringsPeeringId request
	GetProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PostProjectsProjectIdVpcsVpcIdRenameWithBody request with any body
	PostProjectsProjectIdVpcsVpcIdRenameWithBody(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PostProjectsProjectIdVpcsVpcIdRename(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) GetProjectsProjectIdServices(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdServicesRequest(c.Server, projectId)
	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) PostProjectsProjectIdServicesWithBody(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesRequestWithBody(c.Server, projectId, 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) PostProjectsProjectIdServices(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdServicesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesRequest(c.Server, projectId, 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) DeleteProjectsProjectIdServicesServiceId(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProjectsProjectIdServicesServiceIdRequest(c.Server, projectId, serviceId)
	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) GetProjectsProjectIdServicesServiceId(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdServicesServiceIdRequest(c.Server, projectId, serviceId)
	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) PostProjectsProjectIdServicesServiceIdAttachToVPCWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdAttachToVPC(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdAttachToVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequest(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdDetachFromVPC(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdDetachFromVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequest(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdDisablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdDisablePoolerRequest(c.Server, projectId, serviceId)
	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) PostProjectsProjectIdServicesServiceIdEnablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdEnablePoolerRequest(c.Server, projectId, serviceId)
	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) PostProjectsProjectIdServicesServiceIdForkServiceWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdForkServiceRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdForkService(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdForkServiceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdForkServiceRequest(c.Server, projectId, serviceId, 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) GetProjectsProjectIdServicesServiceIdReplicaSets(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdServicesServiceIdReplicaSetsRequest(c.Server, projectId, serviceId)
	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) PostProjectsProjectIdServicesServiceIdReplicaSetsWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdReplicaSets(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdReplicaSetsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequest(c.Server, projectId, serviceId, 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) DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetId(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdRequest(c.Server, projectId, serviceId, replicaSetId)
	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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerRequest(c.Server, projectId, serviceId, replicaSetId)
	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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePooler(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerRequest(c.Server, projectId, serviceId, replicaSetId)
	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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequestWithBody(c.Server, projectId, serviceId, replicaSetId, 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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResize(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequest(c.Server, projectId, serviceId, replicaSetId, 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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequestWithBody(c.Server, projectId, serviceId, replicaSetId, 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) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironment(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequest(c.Server, projectId, serviceId, replicaSetId, 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) PostProjectsProjectIdServicesServiceIdResizeWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdResizeRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdResize(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdResizeRequest(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdSetEnvironment(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequest(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdSetHAWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdSetHARequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdSetHA(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetHAJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdSetHARequest(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBody(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequestWithBody(c.Server, projectId, serviceId, 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) PostProjectsProjectIdServicesServiceIdUpdatePassword(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequest(c.Server, projectId, serviceId, 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) GetProjectsProjectIdVpcs(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdVpcsRequest(c.Server, projectId)
	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) PostProjectsProjectIdVpcsWithBody(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsRequestWithBody(c.Server, projectId, 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) PostProjectsProjectIdVpcs(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsRequest(c.Server, projectId, 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) DeleteProjectsProjectIdVpcsVpcId(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProjectsProjectIdVpcsVpcIdRequest(c.Server, projectId, 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) GetProjectsProjectIdVpcsVpcId(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdVpcsVpcIdRequest(c.Server, projectId, 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) GetProjectsProjectIdVpcsVpcIdPeerings(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdVpcsVpcIdPeeringsRequest(c.Server, projectId, 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) PostProjectsProjectIdVpcsVpcIdPeeringsWithBody(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsVpcIdPeeringsRequestWithBody(c.Server, projectId, 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) PostProjectsProjectIdVpcsVpcIdPeerings(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdPeeringsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsVpcIdPeeringsRequest(c.Server, projectId, 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) DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest(c.Server, projectId, vpcId, peeringId)
	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) GetProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest(c.Server, projectId, vpcId, peeringId)
	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) PostProjectsProjectIdVpcsVpcIdRenameWithBody(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsVpcIdRenameRequestWithBody(c.Server, projectId, 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) PostProjectsProjectIdVpcsVpcIdRename(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProjectsProjectIdVpcsVpcIdRenameRequest(c.Server, projectId, 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)
}

// NewGetProjectsProjectIdServicesRequest generates requests for GetProjectsProjectIdServices
func NewGetProjectsProjectIdServicesRequest(server string, projectId ProjectId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

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

// NewPostProjectsProjectIdServicesRequest calls the generic PostProjectsProjectIdServices builder with application/json body
func NewPostProjectsProjectIdServicesRequest(server string, projectId ProjectId, body PostProjectsProjectIdServicesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesRequestWithBody(server, projectId, "application/json", bodyReader)
}

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

	var pathParam0 string

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

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

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

// NewDeleteProjectsProjectIdServicesServiceIdRequest generates requests for DeleteProjectsProjectIdServicesServiceId
func NewDeleteProjectsProjectIdServicesServiceIdRequest(server string, projectId ProjectId, serviceId ServiceId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewGetProjectsProjectIdServicesServiceIdRequest generates requests for GetProjectsProjectIdServicesServiceId
func NewGetProjectsProjectIdServicesServiceIdRequest(server string, projectId ProjectId, serviceId ServiceId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequest calls the generic PostProjectsProjectIdServicesServiceIdAttachToVPC builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdAttachToVPCJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdAttachToVPC with any type of body
func NewPostProjectsProjectIdServicesServiceIdAttachToVPCRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequest calls the generic PostProjectsProjectIdServicesServiceIdDetachFromVPC builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdDetachFromVPCJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdDetachFromVPC with any type of body
func NewPostProjectsProjectIdServicesServiceIdDetachFromVPCRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdDisablePoolerRequest generates requests for PostProjectsProjectIdServicesServiceIdDisablePooler
func NewPostProjectsProjectIdServicesServiceIdDisablePoolerRequest(server string, projectId ProjectId, serviceId ServiceId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdEnablePoolerRequest generates requests for PostProjectsProjectIdServicesServiceIdEnablePooler
func NewPostProjectsProjectIdServicesServiceIdEnablePoolerRequest(server string, projectId ProjectId, serviceId ServiceId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdForkServiceRequest calls the generic PostProjectsProjectIdServicesServiceIdForkService builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdForkServiceRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdForkServiceJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdForkServiceRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdForkServiceRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdForkService with any type of body
func NewPostProjectsProjectIdServicesServiceIdForkServiceRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewGetProjectsProjectIdServicesServiceIdReplicaSetsRequest generates requests for GetProjectsProjectIdServicesServiceIdReplicaSets
func NewGetProjectsProjectIdServicesServiceIdReplicaSetsRequest(server string, projectId ProjectId, serviceId ServiceId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequest calls the generic PostProjectsProjectIdServicesServiceIdReplicaSets builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdReplicaSetsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdReplicaSets with any type of body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewDeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdRequest generates requests for DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetId
func NewDeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdRequest(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "replica_set_id", runtime.ParamLocationPath, replicaSetId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/services/%s/replicaSets/%s", pathParam0, pathParam1, pathParam2)
	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
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerRequest generates requests for PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePooler
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerRequest(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "replica_set_id", runtime.ParamLocationPath, replicaSetId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/services/%s/replicaSets/%s/disablePooler", pathParam0, pathParam1, pathParam2)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerRequest generates requests for PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePooler
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerRequest(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "replica_set_id", runtime.ParamLocationPath, replicaSetId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/services/%s/replicaSets/%s/enablePooler", pathParam0, pathParam1, pathParam2)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequest calls the generic PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResize builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequest(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequestWithBody(server, projectId, serviceId, replicaSetId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResize with any type of body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "replica_set_id", runtime.ParamLocationPath, replicaSetId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/services/%s/replicaSets/%s/resize", pathParam0, pathParam1, pathParam2)
	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
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequest calls the generic PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironment builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequest(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequestWithBody(server, projectId, serviceId, replicaSetId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironment with any type of body
func NewPostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "replica_set_id", runtime.ParamLocationPath, replicaSetId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/services/%s/replicaSets/%s/setEnvironment", pathParam0, pathParam1, pathParam2)
	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
}

// NewPostProjectsProjectIdServicesServiceIdResizeRequest calls the generic PostProjectsProjectIdServicesServiceIdResize builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdResizeRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdResizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdResizeRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdResizeRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdResize with any type of body
func NewPostProjectsProjectIdServicesServiceIdResizeRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequest calls the generic PostProjectsProjectIdServicesServiceIdSetEnvironment builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetEnvironmentJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdSetEnvironment with any type of body
func NewPostProjectsProjectIdServicesServiceIdSetEnvironmentRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdSetHARequest calls the generic PostProjectsProjectIdServicesServiceIdSetHA builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdSetHARequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetHAJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdSetHARequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdSetHARequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdSetHA with any type of body
func NewPostProjectsProjectIdServicesServiceIdSetHARequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequest calls the generic PostProjectsProjectIdServicesServiceIdUpdatePassword builder with application/json body
func NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequest(server string, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdUpdatePasswordJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequestWithBody(server, projectId, serviceId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequestWithBody generates requests for PostProjectsProjectIdServicesServiceIdUpdatePassword with any type of body
func NewPostProjectsProjectIdServicesServiceIdUpdatePasswordRequestWithBody(server string, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewGetProjectsProjectIdVpcsRequest generates requests for GetProjectsProjectIdVpcs
func NewGetProjectsProjectIdVpcsRequest(server string, projectId ProjectId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

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

// NewPostProjectsProjectIdVpcsRequest calls the generic PostProjectsProjectIdVpcs builder with application/json body
func NewPostProjectsProjectIdVpcsRequest(server string, projectId ProjectId, body PostProjectsProjectIdVpcsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdVpcsRequestWithBody(server, projectId, "application/json", bodyReader)
}

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

	var pathParam0 string

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

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

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

// NewDeleteProjectsProjectIdVpcsVpcIdRequest generates requests for DeleteProjectsProjectIdVpcsVpcId
func NewDeleteProjectsProjectIdVpcsVpcIdRequest(server string, projectId ProjectId, vpcId VPCId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewGetProjectsProjectIdVpcsVpcIdRequest generates requests for GetProjectsProjectIdVpcsVpcId
func NewGetProjectsProjectIdVpcsVpcIdRequest(server string, projectId ProjectId, vpcId VPCId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewGetProjectsProjectIdVpcsVpcIdPeeringsRequest generates requests for GetProjectsProjectIdVpcsVpcIdPeerings
func NewGetProjectsProjectIdVpcsVpcIdPeeringsRequest(server string, projectId ProjectId, vpcId VPCId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

// NewPostProjectsProjectIdVpcsVpcIdPeeringsRequest calls the generic PostProjectsProjectIdVpcsVpcIdPeerings builder with application/json body
func NewPostProjectsProjectIdVpcsVpcIdPeeringsRequest(server string, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdPeeringsJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdVpcsVpcIdPeeringsRequestWithBody(server, projectId, vpcId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdVpcsVpcIdPeeringsRequestWithBody generates requests for PostProjectsProjectIdVpcsVpcIdPeerings with any type of body
func NewPostProjectsProjectIdVpcsVpcIdPeeringsRequestWithBody(server string, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

// NewDeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest generates requests for DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringId
func NewDeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest(server string, projectId ProjectId, vpcId VPCId, peeringId PeeringId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "peering_id", runtime.ParamLocationPath, peeringId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/vpcs/%s/peerings/%s", pathParam0, pathParam1, pathParam2)
	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
}

// NewGetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest generates requests for GetProjectsProjectIdVpcsVpcIdPeeringsPeeringId
func NewGetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdRequest(server string, projectId ProjectId, vpcId VPCId, peeringId PeeringId) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "peering_id", runtime.ParamLocationPath, peeringId)
	if err != nil {
		return nil, err
	}

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

	operationPath := fmt.Sprintf("/projects/%s/vpcs/%s/peerings/%s", pathParam0, pathParam1, pathParam2)
	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
}

// NewPostProjectsProjectIdVpcsVpcIdRenameRequest calls the generic PostProjectsProjectIdVpcsVpcIdRename builder with application/json body
func NewPostProjectsProjectIdVpcsVpcIdRenameRequest(server string, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdRenameJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostProjectsProjectIdVpcsVpcIdRenameRequestWithBody(server, projectId, vpcId, "application/json", bodyReader)
}

// NewPostProjectsProjectIdVpcsVpcIdRenameRequestWithBody generates requests for PostProjectsProjectIdVpcsVpcIdRename with any type of body
func NewPostProjectsProjectIdVpcsVpcIdRenameRequestWithBody(server string, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

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

	var pathParam1 string

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

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

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

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

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

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

	return req, nil
}

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 {
	// GetProjectsProjectIdServicesWithResponse request
	GetProjectsProjectIdServicesWithResponse(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesResponse, error)

	// PostProjectsProjectIdServicesWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesWithBodyWithResponse(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesResponse, error)

	PostProjectsProjectIdServicesWithResponse(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdServicesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesResponse, error)

	// DeleteProjectsProjectIdServicesServiceIdWithResponse request
	DeleteProjectsProjectIdServicesServiceIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdServicesServiceIdResponse, error)

	// GetProjectsProjectIdServicesServiceIdWithResponse request
	GetProjectsProjectIdServicesServiceIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesServiceIdResponse, error)

	// PostProjectsProjectIdServicesServiceIdAttachToVPCWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdAttachToVPCWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdAttachToVPCResponse, error)

	PostProjectsProjectIdServicesServiceIdAttachToVPCWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdAttachToVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdAttachToVPCResponse, error)

	// PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse, error)

	PostProjectsProjectIdServicesServiceIdDetachFromVPCWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdDetachFromVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse, error)

	// PostProjectsProjectIdServicesServiceIdDisablePoolerWithResponse request
	PostProjectsProjectIdServicesServiceIdDisablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDisablePoolerResponse, error)

	// PostProjectsProjectIdServicesServiceIdEnablePoolerWithResponse request
	PostProjectsProjectIdServicesServiceIdEnablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdEnablePoolerResponse, error)

	// PostProjectsProjectIdServicesServiceIdForkServiceWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdForkServiceWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdForkServiceResponse, error)

	PostProjectsProjectIdServicesServiceIdForkServiceWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdForkServiceJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdForkServiceResponse, error)

	// GetProjectsProjectIdServicesServiceIdReplicaSetsWithResponse request
	GetProjectsProjectIdServicesServiceIdReplicaSetsWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesServiceIdReplicaSetsResponse, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsResponse, error)

	PostProjectsProjectIdServicesServiceIdReplicaSetsWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdReplicaSetsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsResponse, error)

	// DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdWithResponse request
	DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResponse, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerWithResponse request
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerResponse, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerWithResponse request
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerResponse, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse, error)

	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse, error)

	// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse, error)

	PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse, error)

	// PostProjectsProjectIdServicesServiceIdResizeWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdResizeWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdResizeResponse, error)

	PostProjectsProjectIdServicesServiceIdResizeWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdResizeResponse, error)

	// PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse, error)

	PostProjectsProjectIdServicesServiceIdSetEnvironmentWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse, error)

	// PostProjectsProjectIdServicesServiceIdSetHAWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdSetHAWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetHAResponse, error)

	PostProjectsProjectIdServicesServiceIdSetHAWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetHAJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetHAResponse, error)

	// PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBodyWithResponse request with any body
	PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse, error)

	PostProjectsProjectIdServicesServiceIdUpdatePasswordWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse, error)

	// GetProjectsProjectIdVpcsWithResponse request
	GetProjectsProjectIdVpcsWithResponse(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsResponse, error)

	// PostProjectsProjectIdVpcsWithBodyWithResponse request with any body
	PostProjectsProjectIdVpcsWithBodyWithResponse(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsResponse, error)

	PostProjectsProjectIdVpcsWithResponse(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsResponse, error)

	// DeleteProjectsProjectIdVpcsVpcIdWithResponse request
	DeleteProjectsProjectIdVpcsVpcIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdVpcsVpcIdResponse, error)

	// GetProjectsProjectIdVpcsVpcIdWithResponse request
	GetProjectsProjectIdVpcsVpcIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdResponse, error)

	// GetProjectsProjectIdVpcsVpcIdPeeringsWithResponse request
	GetProjectsProjectIdVpcsVpcIdPeeringsWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdPeeringsResponse, error)

	// PostProjectsProjectIdVpcsVpcIdPeeringsWithBodyWithResponse request with any body
	PostProjectsProjectIdVpcsVpcIdPeeringsWithBodyWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdPeeringsResponse, error)

	PostProjectsProjectIdVpcsVpcIdPeeringsWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdPeeringsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdPeeringsResponse, error)

	// DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse request
	DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse, error)

	// GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse request
	GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse, error)

	// PostProjectsProjectIdVpcsVpcIdRenameWithBodyWithResponse request with any body
	PostProjectsProjectIdVpcsVpcIdRenameWithBodyWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdRenameResponse, error)

	PostProjectsProjectIdVpcsVpcIdRenameWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdRenameResponse, error)
}

type GetProjectsProjectIdServicesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Service
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *Service
	JSON4XX      *ClientError
}

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

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

type DeleteProjectsProjectIdServicesServiceIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdServicesServiceIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Service
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdAttachToVPCResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdDisablePoolerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdEnablePoolerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdForkServiceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *Service
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdServicesServiceIdReplicaSetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]ReadReplicaSet
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdReplicaSetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *ReadReplicaSet
	JSON4XX      *ClientError
}

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

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

type DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdResizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SuccessMessage
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdSetHAResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *Service
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdVpcsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]VPC
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdVpcsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *VPC
	JSON4XX      *ClientError
}

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

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

type DeleteProjectsProjectIdVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdVpcsVpcIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VPC
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdVpcsVpcIdPeeringsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Peering
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdVpcsVpcIdPeeringsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Peering
	JSON4XX      *ClientError
}

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

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

type DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON4XX      *ClientError
}

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

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

type GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Peering
	JSON4XX      *ClientError
}

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

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

type PostProjectsProjectIdVpcsVpcIdRenameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VPC
	JSON4XX      *ClientError
}

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

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

// GetProjectsProjectIdServicesWithResponse request returning *GetProjectsProjectIdServicesResponse
func (c *ClientWithResponses) GetProjectsProjectIdServicesWithResponse(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesResponse, error) {
	rsp, err := c.GetProjectsProjectIdServices(ctx, projectId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdServicesResponse(rsp)
}

// PostProjectsProjectIdServicesWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesWithBodyWithResponse(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesWithBody(ctx, projectId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesWithResponse(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdServicesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesResponse, error) {
	rsp, err := c.PostProjectsProjectIdServices(ctx, projectId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesResponse(rsp)
}

// DeleteProjectsProjectIdServicesServiceIdWithResponse request returning *DeleteProjectsProjectIdServicesServiceIdResponse
func (c *ClientWithResponses) DeleteProjectsProjectIdServicesServiceIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdServicesServiceIdResponse, error) {
	rsp, err := c.DeleteProjectsProjectIdServicesServiceId(ctx, projectId, serviceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProjectsProjectIdServicesServiceIdResponse(rsp)
}

// GetProjectsProjectIdServicesServiceIdWithResponse request returning *GetProjectsProjectIdServicesServiceIdResponse
func (c *ClientWithResponses) GetProjectsProjectIdServicesServiceIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesServiceIdResponse, error) {
	rsp, err := c.GetProjectsProjectIdServicesServiceId(ctx, projectId, serviceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdServicesServiceIdResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdAttachToVPCWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdAttachToVPCResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdAttachToVPCWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdAttachToVPCResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdAttachToVPCWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdAttachToVPCResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdAttachToVPCWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdAttachToVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdAttachToVPCResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdAttachToVPC(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdAttachToVPCResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdDetachFromVPCWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdDetachFromVPCResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdDetachFromVPCWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdDetachFromVPCJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDetachFromVPCResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdDetachFromVPC(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdDetachFromVPCResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdDisablePoolerWithResponse request returning *PostProjectsProjectIdServicesServiceIdDisablePoolerResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdDisablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdDisablePoolerResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdDisablePooler(ctx, projectId, serviceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdDisablePoolerResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdEnablePoolerWithResponse request returning *PostProjectsProjectIdServicesServiceIdEnablePoolerResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdEnablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdEnablePoolerResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdEnablePooler(ctx, projectId, serviceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdEnablePoolerResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdForkServiceWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdForkServiceResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdForkServiceWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdForkServiceResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdForkServiceWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdForkServiceResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdForkServiceWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdForkServiceJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdForkServiceResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdForkService(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdForkServiceResponse(rsp)
}

// GetProjectsProjectIdServicesServiceIdReplicaSetsWithResponse request returning *GetProjectsProjectIdServicesServiceIdReplicaSetsResponse
func (c *ClientWithResponses) GetProjectsProjectIdServicesServiceIdReplicaSetsWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdServicesServiceIdReplicaSetsResponse, error) {
	rsp, err := c.GetProjectsProjectIdServicesServiceIdReplicaSets(ctx, projectId, serviceId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdServicesServiceIdReplicaSetsResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdReplicaSetsWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdReplicaSetsResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdReplicaSetsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSets(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsResponse(rsp)
}

// DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdWithResponse request returning *DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResponse
func (c *ClientWithResponses) DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResponse, error) {
	rsp, err := c.DeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetId(ctx, projectId, serviceId, replicaSetId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerWithResponse request returning *PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePooler(ctx, projectId, serviceId, replicaSetId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdDisablePoolerResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerWithResponse request returning *PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePooler(ctx, projectId, serviceId, replicaSetId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdEnablePoolerResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithBody(ctx, projectId, serviceId, replicaSetId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResize(ctx, projectId, serviceId, replicaSetId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdResizeResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithBody(ctx, projectId, serviceId, replicaSetId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, replicaSetId ReplicaSetId, body PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironment(ctx, projectId, serviceId, replicaSetId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdReplicaSetsReplicaSetIdSetEnvironmentResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdResizeWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdResizeResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdResizeWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdResizeResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdResizeWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdResizeResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdResizeWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdResizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdResizeResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdResize(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdResizeResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdSetEnvironmentWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdSetEnvironmentResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdSetEnvironmentWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetEnvironmentJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetEnvironmentResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdSetEnvironment(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdSetEnvironmentResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdSetHAWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdSetHAResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdSetHAWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetHAResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdSetHAWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdSetHAResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdSetHAWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdSetHAJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdSetHAResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdSetHA(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdSetHAResponse(rsp)
}

// PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse
func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBodyWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdUpdatePasswordWithBody(ctx, projectId, serviceId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdUpdatePasswordResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdServicesServiceIdUpdatePasswordWithResponse(ctx context.Context, projectId ProjectId, serviceId ServiceId, body PostProjectsProjectIdServicesServiceIdUpdatePasswordJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdServicesServiceIdUpdatePasswordResponse, error) {
	rsp, err := c.PostProjectsProjectIdServicesServiceIdUpdatePassword(ctx, projectId, serviceId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdServicesServiceIdUpdatePasswordResponse(rsp)
}

// GetProjectsProjectIdVpcsWithResponse request returning *GetProjectsProjectIdVpcsResponse
func (c *ClientWithResponses) GetProjectsProjectIdVpcsWithResponse(ctx context.Context, projectId ProjectId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsResponse, error) {
	rsp, err := c.GetProjectsProjectIdVpcs(ctx, projectId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdVpcsResponse(rsp)
}

// PostProjectsProjectIdVpcsWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdVpcsResponse
func (c *ClientWithResponses) PostProjectsProjectIdVpcsWithBodyWithResponse(ctx context.Context, projectId ProjectId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcsWithBody(ctx, projectId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdVpcsWithResponse(ctx context.Context, projectId ProjectId, body PostProjectsProjectIdVpcsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcs(ctx, projectId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsResponse(rsp)
}

// DeleteProjectsProjectIdVpcsVpcIdWithResponse request returning *DeleteProjectsProjectIdVpcsVpcIdResponse
func (c *ClientWithResponses) DeleteProjectsProjectIdVpcsVpcIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdVpcsVpcIdResponse, error) {
	rsp, err := c.DeleteProjectsProjectIdVpcsVpcId(ctx, projectId, vpcId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProjectsProjectIdVpcsVpcIdResponse(rsp)
}

// GetProjectsProjectIdVpcsVpcIdWithResponse request returning *GetProjectsProjectIdVpcsVpcIdResponse
func (c *ClientWithResponses) GetProjectsProjectIdVpcsVpcIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdResponse, error) {
	rsp, err := c.GetProjectsProjectIdVpcsVpcId(ctx, projectId, vpcId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdVpcsVpcIdResponse(rsp)
}

// GetProjectsProjectIdVpcsVpcIdPeeringsWithResponse request returning *GetProjectsProjectIdVpcsVpcIdPeeringsResponse
func (c *ClientWithResponses) GetProjectsProjectIdVpcsVpcIdPeeringsWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdPeeringsResponse, error) {
	rsp, err := c.GetProjectsProjectIdVpcsVpcIdPeerings(ctx, projectId, vpcId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdVpcsVpcIdPeeringsResponse(rsp)
}

// PostProjectsProjectIdVpcsVpcIdPeeringsWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdVpcsVpcIdPeeringsResponse
func (c *ClientWithResponses) PostProjectsProjectIdVpcsVpcIdPeeringsWithBodyWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdPeeringsResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcsVpcIdPeeringsWithBody(ctx, projectId, vpcId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsVpcIdPeeringsResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdVpcsVpcIdPeeringsWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdPeeringsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdPeeringsResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcsVpcIdPeerings(ctx, projectId, vpcId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsVpcIdPeeringsResponse(rsp)
}

// DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse request returning *DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse
func (c *ClientWithResponses) DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse, error) {
	rsp, err := c.DeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx, projectId, vpcId, peeringId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDeleteProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse(rsp)
}

// GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse request returning *GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse
func (c *ClientWithResponses) GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, peeringId PeeringId, reqEditors ...RequestEditorFn) (*GetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse, error) {
	rsp, err := c.GetProjectsProjectIdVpcsVpcIdPeeringsPeeringId(ctx, projectId, vpcId, peeringId, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetProjectsProjectIdVpcsVpcIdPeeringsPeeringIdResponse(rsp)
}

// PostProjectsProjectIdVpcsVpcIdRenameWithBodyWithResponse request with arbitrary body returning *PostProjectsProjectIdVpcsVpcIdRenameResponse
func (c *ClientWithResponses) PostProjectsProjectIdVpcsVpcIdRenameWithBodyWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdRenameResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcsVpcIdRenameWithBody(ctx, projectId, vpcId, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsVpcIdRenameResponse(rsp)
}

func (c *ClientWithResponses) PostProjectsProjectIdVpcsVpcIdRenameWithResponse(ctx context.Context, projectId ProjectId, vpcId VPCId, body PostProjectsProjectIdVpcsVpcIdRenameJSONRequestBody, reqEditors ...RequestEditorFn) (*PostProjectsProjectIdVpcsVpcIdRenameResponse, error) {
	rsp, err := c.PostProjectsProjectIdVpcsVpcIdRename(ctx, projectId, vpcId, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProjectsProjectIdVpcsVpcIdRenameResponse(rsp)
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode/100 == 4:
		var dest ClientError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON4XX = &dest

	}

	return response, nil
}