func (c *client) Post(request rest.Request) error {
	return c.call(rest.PostMethod, request, nil)
}
This method will create and execute a http Post request
It expects no response, that is why it does not ask for a responseObject
package gotransip
import (
	"errors"
	"fmt"
	"github.com/transip/gotransip/v6/authenticator"
	"github.com/transip/gotransip/v6/jwt"
	"github.com/transip/gotransip/v6/repository"
	"github.com/transip/gotransip/v6/rest"
	"io"
	"io/ioutil"
	"net/http"
	"os"
)
type client struct {
	config ClientConfiguration
	authenticator *authenticator.Authenticator
}
const httpBodyLimit = 1024 * 1024 * 4
func NewClient(config ClientConfiguration) (repository.Client, error) {
	return newClient(config)
}
func newClient(config ClientConfiguration) (*client, error) {
	if config.HTTPClient == nil {
		config.HTTPClient = http.DefaultClient
	}
	var privateKeyBody []byte
	var token jwt.Token
	if len(config.AccountName) == 0 && len(config.Token) == 0 {
		return &client{}, errors.New("AccountName is required")
	}
	if len(config.PrivateKeyPath) > 0 && config.PrivateKeyReader == nil {
		privateKeyFile, err := os.Open(config.PrivateKeyPath)
		config.PrivateKeyReader = privateKeyFile
		if err != nil {
			return &client{}, fmt.Errorf("error while opening private key file: %w", err)
		}
	}
	if len(config.Token) == 0 && config.PrivateKeyReader == nil {
		return &client{}, errors.New("PrivateKeyReader, token or PrivateKeyReader is required")
	}
	if config.PrivateKeyReader != nil {
		var err error
		privateKeyBody, err = ioutil.ReadAll(config.PrivateKeyReader)
		if err != nil {
			return &client{}, fmt.Errorf("error while reading private key: %w", err)
		}
	}
	if len(config.Token) > 0 {
		var err error
		token, err = jwt.New(config.Token)
		if err != nil {
			return &client{}, err
		}
	}
	if len(config.Mode) == 0 {
		config.Mode = APIModeReadWrite
	}
	if len(config.URL) == 0 {
		config.URL = defaultBasePath
	}
	return &client{
		authenticator: &authenticator.Authenticator{
			Login:           config.AccountName,
			PrivateKeyBody:  privateKeyBody,
			Token:           token,
			HTTPClient:      config.HTTPClient,
			TokenCache:      config.TokenCache,
			BasePath:        config.URL,
			ReadOnly:        config.Mode == APIModeReadOnly,
			TokenExpiration: config.TokenExpiration,
			Whitelisted:     config.TokenWhitelisted,
		},
		config: config,
	}, nil
}
func (c *client) call(method rest.Method, request rest.Request, result interface{}) error {
	token, err := c.authenticator.GetToken()
	if err != nil {
		return fmt.Errorf("could not get token from authenticator: %w", err)
	}
	if c.config.TestMode {
		request.TestMode = true
	}
	httpRequest, err := request.GetHTTPRequest(c.config.URL, method.Method)
	if err != nil {
		return fmt.Errorf("error during request creation: %w", err)
	}
	httpRequest.Header.Add("Authorization", token.GetAuthenticationHeaderValue())
	httpRequest.Header.Set("User-Agent", userAgent)
	client := c.config.HTTPClient
	httpResponse, err := client.Do(httpRequest)
	if err != nil {
		return fmt.Errorf("request error: %w", err)
	}
	defer httpResponse.Body.Close()
	bodyReader := io.LimitReader(httpResponse.Body, httpBodyLimit)
	b, err := ioutil.ReadAll(bodyReader)
	if err != nil {
		return fmt.Errorf("error reading http response body: %w", err)
	}
	restResponse := rest.Response{
		Body:       b,
		StatusCode: httpResponse.StatusCode,
		Method:     method,
	}
	return restResponse.ParseResponse(&result)
}
func (c *client) ChangeBasePath(path string) {
	c.config.URL = path
}
func (c *client) GetConfig() ClientConfiguration {
	return c.config
}
func (c *client) GetAuthenticator() *authenticator.Authenticator {
	return c.authenticator
}
func (c *client) Get(request rest.Request, responseObject interface{}) error {
	return c.call(rest.GetMethod, request, responseObject)
}