feat: auto generated files and new structure (#4)

## Description

<!-- **Please link some issue here describing what you are trying to achieve.**

In case there is no issue present for your PR, please consider creating one.
At least please give us some description what you are trying to achieve and why your change is needed. -->

relates to #1234

## Checklist

- [ ] Issue was linked above
- [ ] Code format was applied: `make fmt`
- [ ] Examples were added / adjusted (see `examples/` directory)
- [x] Docs are up-to-date: `make generate-docs` (will be checked by CI)
- [ ] Unit tests got implemented or updated
- [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go))
- [x] Unit tests are passing: `make test` (will be checked by CI)
- [x] No linter issues: `make lint` (will be checked by CI)

Reviewed-on: #4
Reviewed-by: Andre_Harms <andre.harms@stackit.cloud>
Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-committed-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>

pkg/certificatesbeta/.openapi-generator/VERSION

@@ -0,0 +1 @@
+6.6.0

pkg/certificatesbeta/api_default.go

@@ -0,0 +1,758 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+)
+
+type DefaultApi interface {
+	/*
+		CreateCertificate Store a TLS certificate in a project.
+		CreateCertificate will store a TLS certificate in a project.
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@return ApiCreateCertificateRequest
+	*/
+	CreateCertificate(ctx context.Context, projectId string, region string) ApiCreateCertificateRequest
+	/*
+		CreateCertificateExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@return CreateCertificateResponse
+
+	*/
+	CreateCertificateExecute(ctx context.Context, projectId string, region string) (*CreateCertificateResponse, error)
+	/*
+		DeleteCertificate Delete a stored TLS certificate in a project.
+		DeleteCertificate will delete the stored TLS certificate.
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@param id
+		@return ApiDeleteCertificateRequest
+	*/
+	DeleteCertificate(ctx context.Context, projectId string, region string, id string) ApiDeleteCertificateRequest
+	/*
+		DeleteCertificateExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@param id
+		@return map[string]interface{}
+
+	*/
+	DeleteCertificateExecute(ctx context.Context, projectId string, region string, id string) (map[string]interface{}, error)
+	/*
+		GetCertificate Retrieve the public parts of a stored TLS certificate.
+		GetCertificate will return the public parts of a stored TLS certificate.
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@param id
+		@return ApiGetCertificateRequest
+	*/
+	GetCertificate(ctx context.Context, projectId string, region string, id string) ApiGetCertificateRequest
+	/*
+		GetCertificateExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@param id
+		@return GetCertificateResponse
+
+	*/
+	GetCertificateExecute(ctx context.Context, projectId string, region string, id string) (*GetCertificateResponse, error)
+	/*
+		ListCertificates Retrieve the list of TLS certificate stored in a project.
+		ListCertificates will return the list of TLS certificates in a project.
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@return ApiListCertificatesRequest
+	*/
+	ListCertificates(ctx context.Context, projectId string, region string) ApiListCertificatesRequest
+	/*
+		ListCertificatesExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId
+		@param region
+		@return ListCertificatesResponse
+
+	*/
+	ListCertificatesExecute(ctx context.Context, projectId string, region string) (*ListCertificatesResponse, error)
+}
+
+type ApiCreateCertificateRequest interface {
+	CreateCertificatePayload(createCertificatePayload CreateCertificatePayload) ApiCreateCertificateRequest
+	Execute() (*CreateCertificateResponse, error)
+}
+
+type ApiDeleteCertificateRequest interface {
+	Execute() (map[string]interface{}, error)
+}
+
+type ApiGetCertificateRequest interface {
+	Execute() (*GetCertificateResponse, error)
+}
+
+type ApiListCertificatesRequest interface {
+	// page_size specifies how many certificates should be returned on this page. Must be a positive number <= 1000
+	PageSize(pageSize string) ApiListCertificatesRequest
+	// page_id is a page identifier returned by the previous response and is used to request the next page
+	PageId(pageId string) ApiListCertificatesRequest
+	Execute() (*ListCertificatesResponse, error)
+}
+
+// DefaultApiService DefaultApi service
+type DefaultApiService service
+
+type CreateCertificateRequest struct {
+	ctx                      context.Context
+	apiService               *DefaultApiService
+	projectId                string
+	region                   string
+	createCertificatePayload *CreateCertificatePayload
+}
+
+func (r CreateCertificateRequest) CreateCertificatePayload(createCertificatePayload CreateCertificatePayload) ApiCreateCertificateRequest {
+	r.createCertificatePayload = &createCertificatePayload
+	return r
+}
+
+func (r CreateCertificateRequest) Execute() (*CreateCertificateResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodPost
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CreateCertificateResponse
+	)
+	a := r.apiService
+	client, ok := a.client.(*APIClient)
+	if !ok {
+		return localVarReturnValue, fmt.Errorf("could not parse client to type APIClient")
+	}
+	localBasePath, err := client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.CreateCertificate")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/certificates"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+	if r.createCertificatePayload == nil {
+		return localVarReturnValue, fmt.Errorf("createCertificatePayload is required and must be specified")
+	}
+
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{"application/json"}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json", "*/*"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	// body params
+	localVarPostBody = r.createCertificatePayload
+	req, err := client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request)
+	if ok {
+		*contextHTTPRequest = req
+	}
+
+	localVarHTTPResponse, err := client.callAPI(req)
+	contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response)
+	if ok {
+		*contextHTTPResponse = localVarHTTPResponse
+	}
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Status
+			err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.ErrorMessage = err.Error()
+				return localVarReturnValue, newErr
+			}
+			newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.Model = v
+			return localVarReturnValue, newErr
+		}
+		var v Status
+		err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+		if err != nil {
+			newErr.ErrorMessage = err.Error()
+			return localVarReturnValue, newErr
+		}
+		newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+		newErr.Model = v
+		return localVarReturnValue, newErr
+	}
+
+	err = client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, newErr
+	}
+
+	return localVarReturnValue, nil
+}
+
+/*
+CreateCertificate: Store a TLS certificate in a project.
+
+CreateCertificate will store a TLS certificate in a project.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId
+	@param region
+	@return ApiCreateCertificateRequest
+*/
+func (a *APIClient) CreateCertificate(ctx context.Context, projectId string, region string) ApiCreateCertificateRequest {
+	return CreateCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+	}
+}
+
+func (a *APIClient) CreateCertificateExecute(ctx context.Context, projectId string, region string) (*CreateCertificateResponse, error) {
+	r := CreateCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+	}
+	return r.Execute()
+}
+
+type DeleteCertificateRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	projectId  string
+	region     string
+	id         string
+}
+
+func (r DeleteCertificateRequest) Execute() (map[string]interface{}, error) {
+	var (
+		localVarHTTPMethod  = http.MethodDelete
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue map[string]interface{}
+	)
+	a := r.apiService
+	client, ok := a.client.(*APIClient)
+	if !ok {
+		return localVarReturnValue, fmt.Errorf("could not parse client to type APIClient")
+	}
+	localBasePath, err := client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.DeleteCertificate")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/certificates/{id}"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(ParameterValueToString(r.id, "id")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json", "*/*"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request)
+	if ok {
+		*contextHTTPRequest = req
+	}
+
+	localVarHTTPResponse, err := client.callAPI(req)
+	contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response)
+	if ok {
+		*contextHTTPResponse = localVarHTTPResponse
+	}
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Status
+			err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.ErrorMessage = err.Error()
+				return localVarReturnValue, newErr
+			}
+			newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.Model = v
+			return localVarReturnValue, newErr
+		}
+		var v Status
+		err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+		if err != nil {
+			newErr.ErrorMessage = err.Error()
+			return localVarReturnValue, newErr
+		}
+		newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+		newErr.Model = v
+		return localVarReturnValue, newErr
+	}
+
+	err = client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, newErr
+	}
+
+	return localVarReturnValue, nil
+}
+
+/*
+DeleteCertificate: Delete a stored TLS certificate in a project.
+
+DeleteCertificate will delete the stored TLS certificate.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId
+	@param region
+	@param id
+	@return ApiDeleteCertificateRequest
+*/
+func (a *APIClient) DeleteCertificate(ctx context.Context, projectId string, region string, id string) ApiDeleteCertificateRequest {
+	return DeleteCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		id:         id,
+	}
+}
+
+func (a *APIClient) DeleteCertificateExecute(ctx context.Context, projectId string, region string, id string) (map[string]interface{}, error) {
+	r := DeleteCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		id:         id,
+	}
+	return r.Execute()
+}
+
+type GetCertificateRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	projectId  string
+	region     string
+	id         string
+}
+
+func (r GetCertificateRequest) Execute() (*GetCertificateResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *GetCertificateResponse
+	)
+	a := r.apiService
+	client, ok := a.client.(*APIClient)
+	if !ok {
+		return localVarReturnValue, fmt.Errorf("could not parse client to type APIClient")
+	}
+	localBasePath, err := client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.GetCertificate")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/certificates/{id}"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(ParameterValueToString(r.id, "id")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json", "*/*"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request)
+	if ok {
+		*contextHTTPRequest = req
+	}
+
+	localVarHTTPResponse, err := client.callAPI(req)
+	contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response)
+	if ok {
+		*contextHTTPResponse = localVarHTTPResponse
+	}
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Status
+			err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.ErrorMessage = err.Error()
+				return localVarReturnValue, newErr
+			}
+			newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.Model = v
+			return localVarReturnValue, newErr
+		}
+		var v Status
+		err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+		if err != nil {
+			newErr.ErrorMessage = err.Error()
+			return localVarReturnValue, newErr
+		}
+		newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+		newErr.Model = v
+		return localVarReturnValue, newErr
+	}
+
+	err = client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, newErr
+	}
+
+	return localVarReturnValue, nil
+}
+
+/*
+GetCertificate: Retrieve the public parts of a stored TLS certificate.
+
+GetCertificate will return the public parts of a stored TLS certificate.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId
+	@param region
+	@param id
+	@return ApiGetCertificateRequest
+*/
+func (a *APIClient) GetCertificate(ctx context.Context, projectId string, region string, id string) ApiGetCertificateRequest {
+	return GetCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		id:         id,
+	}
+}
+
+func (a *APIClient) GetCertificateExecute(ctx context.Context, projectId string, region string, id string) (*GetCertificateResponse, error) {
+	r := GetCertificateRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		id:         id,
+	}
+	return r.Execute()
+}
+
+type ListCertificatesRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	projectId  string
+	region     string
+	pageSize   *string
+	pageId     *string
+}
+
+// page_size specifies how many certificates should be returned on this page. Must be a positive number <= 1000
+
+func (r ListCertificatesRequest) PageSize(pageSize string) ApiListCertificatesRequest {
+	r.pageSize = &pageSize
+	return r
+}
+
+// page_id is a page identifier returned by the previous response and is used to request the next page
+
+func (r ListCertificatesRequest) PageId(pageId string) ApiListCertificatesRequest {
+	r.pageId = &pageId
+	return r
+}
+
+func (r ListCertificatesRequest) Execute() (*ListCertificatesResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *ListCertificatesResponse
+	)
+	a := r.apiService
+	client, ok := a.client.(*APIClient)
+	if !ok {
+		return localVarReturnValue, fmt.Errorf("could not parse client to type APIClient")
+	}
+	localBasePath, err := client.cfg.ServerURLWithContext(r.ctx, "DefaultApiService.ListCertificates")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/certificates"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	if r.pageSize != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "pageSize", r.pageSize, "")
+	}
+	if r.pageId != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "pageId", r.pageId, "")
+	}
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json", "*/*"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	contextHTTPRequest, ok := r.ctx.Value(config.ContextHTTPRequest).(**http.Request)
+	if ok {
+		*contextHTTPRequest = req
+	}
+
+	localVarHTTPResponse, err := client.callAPI(req)
+	contextHTTPResponse, ok := r.ctx.Value(config.ContextHTTPResponse).(**http.Response)
+	if ok {
+		*contextHTTPResponse = localVarHTTPResponse
+	}
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Status
+			err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.ErrorMessage = err.Error()
+				return localVarReturnValue, newErr
+			}
+			newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.Model = v
+			return localVarReturnValue, newErr
+		}
+		var v Status
+		err = client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+		if err != nil {
+			newErr.ErrorMessage = err.Error()
+			return localVarReturnValue, newErr
+		}
+		newErr.ErrorMessage = oapierror.FormatErrorMessage(localVarHTTPResponse.Status, &v)
+		newErr.Model = v
+		return localVarReturnValue, newErr
+	}
+
+	err = client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &oapierror.GenericOpenAPIError{
+			StatusCode:   localVarHTTPResponse.StatusCode,
+			Body:         localVarBody,
+			ErrorMessage: err.Error(),
+		}
+		return localVarReturnValue, newErr
+	}
+
+	return localVarReturnValue, nil
+}
+
+/*
+ListCertificates: Retrieve the list of TLS certificate stored in a project.
+
+ListCertificates will return the list of TLS certificates in a project.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId
+	@param region
+	@return ApiListCertificatesRequest
+*/
+func (a *APIClient) ListCertificates(ctx context.Context, projectId string, region string) ApiListCertificatesRequest {
+	return ListCertificatesRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+	}
+}
+
+func (a *APIClient) ListCertificatesExecute(ctx context.Context, projectId string, region string) (*ListCertificatesResponse, error) {
+	r := ListCertificatesRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+	}
+	return r.Execute()
+}

pkg/certificatesbeta/api_default_test.go

@@ -0,0 +1,253 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+Testing DefaultApiService
+
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech);
+
+package certificatesbeta
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+)
+
+func Test_certificatesbeta_DefaultApiService(t *testing.T) {
+
+	t.Run("Test DefaultApiService CreateCertificate", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/certificates"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		regionValue := "region-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(regionValue, "region")), -1)
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := CreateCertificateResponse{}
+			w.Header().Add("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(data)
+		})
+		testServer := httptest.NewServer(testDefaultApiServeMux)
+		defer testServer.Close()
+
+		configuration := &config.Configuration{
+			DefaultHeader: make(map[string]string),
+			UserAgent:     "OpenAPI-Generator/1.0.0/go",
+			Debug:         false,
+			Region:        "test_region",
+			Servers: config.ServerConfigurations{
+				{
+					URL:         testServer.URL,
+					Description: "Localhost for certificatesbeta_DefaultApi",
+					Variables: map[string]config.ServerVariable{
+						"region": {
+							DefaultValue: "test_region.",
+							EnumValues: []string{
+								"test_region.",
+							},
+						},
+					},
+				},
+			},
+			OperationServers: map[string]config.ServerConfigurations{},
+		}
+		apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication())
+		if err != nil {
+			t.Fatalf("creating API client: %v", err)
+		}
+
+		projectId := projectIdValue
+		region := regionValue
+		createCertificatePayload := CreateCertificatePayload{}
+
+		resp, reqErr := apiClient.CreateCertificate(context.Background(), projectId, region).CreateCertificatePayload(createCertificatePayload).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService DeleteCertificate", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/certificates/{id}"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		regionValue := "region-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(regionValue, "region")), -1)
+		idValue := "id-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"id"+"}", url.PathEscape(ParameterValueToString(idValue, "id")), -1)
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := map[string]interface{}{}
+			w.Header().Add("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(data)
+		})
+		testServer := httptest.NewServer(testDefaultApiServeMux)
+		defer testServer.Close()
+
+		configuration := &config.Configuration{
+			DefaultHeader: make(map[string]string),
+			UserAgent:     "OpenAPI-Generator/1.0.0/go",
+			Debug:         false,
+			Region:        "test_region",
+			Servers: config.ServerConfigurations{
+				{
+					URL:         testServer.URL,
+					Description: "Localhost for certificatesbeta_DefaultApi",
+					Variables: map[string]config.ServerVariable{
+						"region": {
+							DefaultValue: "test_region.",
+							EnumValues: []string{
+								"test_region.",
+							},
+						},
+					},
+				},
+			},
+			OperationServers: map[string]config.ServerConfigurations{},
+		}
+		apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication())
+		if err != nil {
+			t.Fatalf("creating API client: %v", err)
+		}
+
+		projectId := projectIdValue
+		region := regionValue
+		id := idValue
+
+		resp, reqErr := apiClient.DeleteCertificate(context.Background(), projectId, region, id).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService GetCertificate", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/certificates/{id}"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		regionValue := "region-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(regionValue, "region")), -1)
+		idValue := "id-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"id"+"}", url.PathEscape(ParameterValueToString(idValue, "id")), -1)
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := GetCertificateResponse{}
+			w.Header().Add("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(data)
+		})
+		testServer := httptest.NewServer(testDefaultApiServeMux)
+		defer testServer.Close()
+
+		configuration := &config.Configuration{
+			DefaultHeader: make(map[string]string),
+			UserAgent:     "OpenAPI-Generator/1.0.0/go",
+			Debug:         false,
+			Region:        "test_region",
+			Servers: config.ServerConfigurations{
+				{
+					URL:         testServer.URL,
+					Description: "Localhost for certificatesbeta_DefaultApi",
+					Variables: map[string]config.ServerVariable{
+						"region": {
+							DefaultValue: "test_region.",
+							EnumValues: []string{
+								"test_region.",
+							},
+						},
+					},
+				},
+			},
+			OperationServers: map[string]config.ServerConfigurations{},
+		}
+		apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication())
+		if err != nil {
+			t.Fatalf("creating API client: %v", err)
+		}
+
+		projectId := projectIdValue
+		region := regionValue
+		id := idValue
+
+		resp, reqErr := apiClient.GetCertificate(context.Background(), projectId, region, id).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService ListCertificates", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/certificates"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		regionValue := "region-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(regionValue, "region")), -1)
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := ListCertificatesResponse{}
+			w.Header().Add("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(data)
+		})
+		testServer := httptest.NewServer(testDefaultApiServeMux)
+		defer testServer.Close()
+
+		configuration := &config.Configuration{
+			DefaultHeader: make(map[string]string),
+			UserAgent:     "OpenAPI-Generator/1.0.0/go",
+			Debug:         false,
+			Region:        "test_region",
+			Servers: config.ServerConfigurations{
+				{
+					URL:         testServer.URL,
+					Description: "Localhost for certificatesbeta_DefaultApi",
+					Variables: map[string]config.ServerVariable{
+						"region": {
+							DefaultValue: "test_region.",
+							EnumValues: []string{
+								"test_region.",
+							},
+						},
+					},
+				},
+			},
+			OperationServers: map[string]config.ServerConfigurations{},
+		}
+		apiClient, err := NewAPIClient(config.WithCustomConfiguration(configuration), config.WithoutAuthentication())
+		if err != nil {
+			t.Fatalf("creating API client: %v", err)
+		}
+
+		projectId := projectIdValue
+		region := regionValue
+
+		resp, reqErr := apiClient.ListCertificates(context.Background(), projectId, region).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+}

pkg/certificatesbeta/client.go

@@ -0,0 +1,628 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/auth"
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+)
+
+var (
+	jsonCheck       = regexp.MustCompile(`(?i:(?:application|text)/(?:vnd\.[^;]+\+)?json)`)
+	xmlCheck        = regexp.MustCompile(`(?i:(?:application|text)/xml)`)
+	queryParamSplit = regexp.MustCompile(`(^|&)([^&]+)`)
+	queryDescape    = strings.NewReplacer("%5B", "[", "%5D", "]")
+)
+
+// APIClient manages communication with the STACKIT Application Load Balancer Certificates API API v2beta.0.0
+// In most cases there should be only one, shared, APIClient.
+type APIClient struct {
+	cfg        *config.Configuration
+	common     service // Reuse a single struct instead of allocating one for each service on the heap.
+	defaultApi *DefaultApiService
+}
+
+type service struct {
+	client DefaultApi
+}
+
+// NewAPIClient creates a new API client.
+// Optionally receives configuration options
+func NewAPIClient(opts ...config.ConfigurationOption) (*APIClient, error) {
+	cfg := NewConfiguration()
+
+	for _, option := range opts {
+		err := option(cfg)
+		if err != nil {
+			return nil, fmt.Errorf("configuring the client: %w", err)
+		}
+	}
+
+	err := config.ConfigureRegion(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("configuring region: %w", err)
+	}
+
+	if cfg.HTTPClient == nil {
+		cfg.HTTPClient = &http.Client{}
+	}
+
+	authRoundTripper, err := auth.SetupAuth(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("setting up authentication: %w", err)
+	}
+
+	roundTripper := authRoundTripper
+	if cfg.Middleware != nil {
+		roundTripper = config.ChainMiddleware(roundTripper, cfg.Middleware...)
+	}
+
+	cfg.HTTPClient.Transport = roundTripper
+
+	c := &APIClient{}
+	c.cfg = cfg
+	c.common.client = c
+	c.defaultApi = (*DefaultApiService)(&c.common)
+
+	return c, nil
+}
+
+func atoi(in string) (int, error) {
+	return strconv.Atoi(in)
+}
+
+// selectHeaderContentType select a content type from the available list.
+func selectHeaderContentType(contentTypes []string) string {
+	if len(contentTypes) == 0 {
+		return ""
+	}
+	if contains(contentTypes, "application/json") {
+		return "application/json"
+	}
+	return contentTypes[0] // use the first content type specified in 'consumes'
+}
+
+// selectHeaderAccept join all accept types and return
+func selectHeaderAccept(accepts []string) string {
+	if len(accepts) == 0 {
+		return ""
+	}
+
+	if contains(accepts, "application/json") {
+		return "application/json"
+	}
+
+	return strings.Join(accepts, ",")
+}
+
+// contains is a case insensitive match, finding needle in a haystack
+func contains(haystack []string, needle string) bool {
+	for _, a := range haystack {
+		if strings.EqualFold(a, needle) {
+			return true
+		}
+	}
+	return false
+}
+
+// Verify optional parameters are of the correct type.
+func typeCheckParameter(obj interface{}, expected string, name string) error {
+	// Make sure there is an object.
+	if obj == nil {
+		return nil
+	}
+
+	// Check the type is as expected.
+	if reflect.TypeOf(obj).String() != expected {
+		return fmt.Errorf("expected %s to be of type %s but received %s", name, expected, reflect.TypeOf(obj).String())
+	}
+	return nil
+}
+
+func ParameterValueToString(obj interface{}, key string) string {
+	if reflect.TypeOf(obj).Kind() != reflect.Ptr {
+		return fmt.Sprintf("%v", obj)
+	}
+	var param, ok = obj.(MappedNullable)
+	if !ok {
+		return ""
+	}
+	dataMap, err := param.ToMap()
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%v", dataMap[key])
+}
+
+// parameterAddToHeaderOrQuery adds the provided object to the request header or url query
+// supporting deep object syntax
+func parameterAddToHeaderOrQuery(headerOrQueryParams interface{}, keyPrefix string, obj interface{}, collectionType string) {
+	var v = reflect.ValueOf(obj)
+	var value = ""
+	if v == reflect.ValueOf(nil) {
+		value = "null"
+	} else {
+		switch v.Kind() {
+		case reflect.Invalid:
+			value = "invalid"
+
+		case reflect.Struct:
+			if t, ok := obj.(MappedNullable); ok {
+				dataMap, err := t.ToMap()
+				if err != nil {
+					return
+				}
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, dataMap, collectionType)
+				return
+			}
+			if t, ok := obj.(time.Time); ok {
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, t.Format(time.RFC3339), collectionType)
+				return
+			}
+			value = v.Type().String() + " value"
+		case reflect.Slice:
+			var indValue = reflect.ValueOf(obj)
+			if indValue == reflect.ValueOf(nil) {
+				return
+			}
+			var lenIndValue = indValue.Len()
+			for i := 0; i < lenIndValue; i++ {
+				var arrayValue = indValue.Index(i)
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, arrayValue.Interface(), collectionType)
+			}
+			return
+
+		case reflect.Map:
+			var indValue = reflect.ValueOf(obj)
+			if indValue == reflect.ValueOf(nil) {
+				return
+			}
+			iter := indValue.MapRange()
+			for iter.Next() {
+				k, v := iter.Key(), iter.Value()
+				parameterAddToHeaderOrQuery(headerOrQueryParams, fmt.Sprintf("%s[%s]", keyPrefix, k.String()), v.Interface(), collectionType)
+			}
+			return
+
+		case reflect.Interface:
+			fallthrough
+		case reflect.Ptr:
+			parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, v.Elem().Interface(), collectionType)
+			return
+
+		case reflect.Int, reflect.Int8, reflect.Int16,
+			reflect.Int32, reflect.Int64:
+			value = strconv.FormatInt(v.Int(), 10)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16,
+			reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			value = strconv.FormatUint(v.Uint(), 10)
+		case reflect.Float32, reflect.Float64:
+			value = strconv.FormatFloat(v.Float(), 'g', -1, 32)
+		case reflect.Bool:
+			value = strconv.FormatBool(v.Bool())
+		case reflect.String:
+			value = v.String()
+		default:
+			value = v.Type().String() + " value"
+		}
+	}
+
+	switch valuesMap := headerOrQueryParams.(type) {
+	case url.Values:
+		if collectionType == "csv" && valuesMap.Get(keyPrefix) != "" {
+			valuesMap.Set(keyPrefix, valuesMap.Get(keyPrefix)+","+value)
+		} else {
+			valuesMap.Add(keyPrefix, value)
+		}
+		break
+	case map[string]string:
+		valuesMap[keyPrefix] = value
+		break
+	}
+}
+
+// helper for converting interface{} parameters to json strings
+func parameterToJson(obj interface{}) (string, error) {
+	jsonBuf, err := json.Marshal(obj)
+	if err != nil {
+		return "", err
+	}
+	return string(jsonBuf), err
+}
+
+// callAPI do the request.
+func (c *APIClient) callAPI(request *http.Request) (*http.Response, error) {
+	if c.cfg.Debug {
+		dump, err := httputil.DumpRequestOut(request, true)
+		if err != nil {
+			return nil, err
+		}
+		log.Printf("\n%s\n", string(dump))
+	}
+
+	resp, err := c.cfg.HTTPClient.Do(request)
+	if err != nil {
+		return resp, err
+	}
+
+	if c.cfg.Debug {
+		dump, err := httputil.DumpResponse(resp, true)
+		if err != nil {
+			return resp, err
+		}
+		log.Printf("\n%s\n", string(dump))
+	}
+	return resp, err
+}
+
+// Allow modification of underlying config for alternate implementations and testing
+// Caution: modifying the configuration while live can cause data races and potentially unwanted behavior
+func (c *APIClient) GetConfig() *config.Configuration {
+	return c.cfg
+}
+
+type formFile struct {
+	fileBytes    []byte
+	fileName     string
+	formFileName string
+}
+
+// prepareRequest build the request
+func (c *APIClient) prepareRequest(
+	ctx context.Context,
+	path string, method string,
+	postBody interface{},
+	headerParams map[string]string,
+	queryParams url.Values,
+	formParams url.Values,
+	formFiles []formFile) (localVarRequest *http.Request, err error) {
+
+	var body *bytes.Buffer
+
+	// Detect postBody type and post.
+	if !IsNil(postBody) {
+		contentType := headerParams["Content-Type"]
+		if contentType == "" {
+			contentType = detectContentType(postBody)
+			headerParams["Content-Type"] = contentType
+		}
+
+		body, err = setBody(postBody, contentType)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// add form parameters and file if available.
+	if strings.HasPrefix(headerParams["Content-Type"], "multipart/form-data") && len(formParams) > 0 || (len(formFiles) > 0) {
+		if body != nil {
+			return nil, fmt.Errorf("cannot specify postBody and multipart form at the same time.")
+		}
+		body = &bytes.Buffer{}
+		w := multipart.NewWriter(body)
+
+		for k, v := range formParams {
+			for _, iv := range v {
+				if strings.HasPrefix(k, "@") { // file
+					err = addFile(w, k[1:], iv)
+					if err != nil {
+						return nil, err
+					}
+				} else { // form value
+					w.WriteField(k, iv)
+				}
+			}
+		}
+		for _, formFile := range formFiles {
+			if len(formFile.fileBytes) > 0 && formFile.fileName != "" {
+				w.Boundary()
+				part, err := w.CreateFormFile(formFile.formFileName, filepath.Base(formFile.fileName))
+				if err != nil {
+					return nil, err
+				}
+				_, err = part.Write(formFile.fileBytes)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+
+		// Set the Boundary in the Content-Type
+		headerParams["Content-Type"] = w.FormDataContentType()
+
+		// Set Content-Length
+		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
+		w.Close()
+	}
+
+	if strings.HasPrefix(headerParams["Content-Type"], "application/x-www-form-urlencoded") && len(formParams) > 0 {
+		if body != nil {
+			return nil, fmt.Errorf("cannot specify postBody and x-www-form-urlencoded form at the same time.")
+		}
+		body = &bytes.Buffer{}
+		body.WriteString(formParams.Encode())
+		// Set Content-Length
+		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
+	}
+
+	// Setup path and query parameters
+	url, err := url.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+
+	// Override request host, if applicable
+	if c.cfg.Host != "" {
+		url.Host = c.cfg.Host
+	}
+
+	// Override request scheme, if applicable
+	if c.cfg.Scheme != "" {
+		url.Scheme = c.cfg.Scheme
+	}
+
+	// Adding Query Param
+	query := url.Query()
+	for k, v := range queryParams {
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	// Encode the parameters.
+	url.RawQuery = queryParamSplit.ReplaceAllStringFunc(query.Encode(), func(s string) string {
+		pieces := strings.Split(s, "=")
+		pieces[0] = queryDescape.Replace(pieces[0])
+		return strings.Join(pieces, "=")
+	})
+
+	// Generate a new request
+	if body != nil {
+		localVarRequest, err = http.NewRequest(method, url.String(), body)
+	} else {
+		localVarRequest, err = http.NewRequest(method, url.String(), nil)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	// add header parameters, if any
+	if len(headerParams) > 0 {
+		headers := http.Header{}
+		for h, v := range headerParams {
+			headers[h] = []string{v}
+		}
+		localVarRequest.Header = headers
+	}
+
+	// Add the user agent to the request.
+	localVarRequest.Header.Add("User-Agent", c.cfg.UserAgent)
+
+	if ctx != nil {
+		// add context to the request
+		localVarRequest = localVarRequest.WithContext(ctx)
+
+		// Walk through any authentication.
+
+	}
+
+	for header, value := range c.cfg.DefaultHeader {
+		localVarRequest.Header.Add(header, value)
+	}
+	return localVarRequest, nil
+}
+
+func (c *APIClient) decode(v interface{}, b []byte, contentType string) (err error) {
+	if len(b) == 0 {
+		return nil
+	}
+	if s, ok := v.(*string); ok {
+		*s = string(b)
+		return nil
+	}
+	if f, ok := v.(*os.File); ok {
+		f, err = os.CreateTemp("", "HttpClientFile")
+		if err != nil {
+			return
+		}
+		_, err = f.Write(b)
+		if err != nil {
+			return
+		}
+		_, err = f.Seek(0, io.SeekStart)
+		return
+	}
+	if f, ok := v.(**os.File); ok {
+		*f, err = os.CreateTemp("", "HttpClientFile")
+		if err != nil {
+			return
+		}
+		_, err = (*f).Write(b)
+		if err != nil {
+			return
+		}
+		_, err = (*f).Seek(0, io.SeekStart)
+		return
+	}
+	if xmlCheck.MatchString(contentType) {
+		if err = xml.Unmarshal(b, v); err != nil {
+			return err
+		}
+		return nil
+	}
+	if jsonCheck.MatchString(contentType) {
+		if actualObj, ok := v.(interface{ GetActualInstance() interface{} }); ok { // oneOf, anyOf schemas
+			if unmarshalObj, ok := actualObj.(interface{ UnmarshalJSON([]byte) error }); ok { // make sure it has UnmarshalJSON defined
+				if err = unmarshalObj.UnmarshalJSON(b); err != nil {
+					return err
+				}
+			} else {
+				return fmt.Errorf("unknown type with GetActualInstance but no unmarshalObj.UnmarshalJSON defined")
+			}
+		} else if err = json.Unmarshal(b, v); err != nil { // simple model
+			return err
+		}
+		return nil
+	}
+	return fmt.Errorf("undefined response type")
+}
+
+// Add a file to the multipart request
+func addFile(w *multipart.Writer, fieldName, path string) error {
+	file, err := os.Open(filepath.Clean(path))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	part, err := w.CreateFormFile(fieldName, filepath.Base(path))
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(part, file)
+
+	return err
+}
+
+// A wrapper for strict JSON decoding
+func newStrictDecoder(data []byte) *json.Decoder {
+	dec := json.NewDecoder(bytes.NewBuffer(data))
+	dec.DisallowUnknownFields()
+	return dec
+}
+
+// Set request body from an interface{}
+func setBody(body interface{}, contentType string) (bodyBuf *bytes.Buffer, err error) {
+	if bodyBuf == nil {
+		bodyBuf = &bytes.Buffer{}
+	}
+
+	if reader, ok := body.(io.Reader); ok {
+		_, err = bodyBuf.ReadFrom(reader)
+	} else if fp, ok := body.(*os.File); ok {
+		_, err = bodyBuf.ReadFrom(fp)
+	} else if b, ok := body.([]byte); ok {
+		_, err = bodyBuf.Write(b)
+	} else if s, ok := body.(string); ok {
+		_, err = bodyBuf.WriteString(s)
+	} else if s, ok := body.(*string); ok {
+		_, err = bodyBuf.WriteString(*s)
+	} else if jsonCheck.MatchString(contentType) {
+		err = json.NewEncoder(bodyBuf).Encode(body)
+	} else if xmlCheck.MatchString(contentType) {
+		err = xml.NewEncoder(bodyBuf).Encode(body)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if bodyBuf.Len() == 0 {
+		err = fmt.Errorf("invalid body type %s", contentType)
+		return nil, err
+	}
+	return bodyBuf, nil
+}
+
+// detectContentType method is used to figure out `Request.Body` content type for request header
+func detectContentType(body interface{}) string {
+	contentType := "text/plain; charset=utf-8"
+	kind := reflect.TypeOf(body).Kind()
+
+	switch kind {
+	case reflect.Struct, reflect.Map, reflect.Ptr:
+		contentType = "application/json; charset=utf-8"
+	case reflect.String:
+		contentType = "text/plain; charset=utf-8"
+	default:
+		if b, ok := body.([]byte); ok {
+			contentType = http.DetectContentType(b)
+		} else if kind == reflect.Slice {
+			contentType = "application/json; charset=utf-8"
+		}
+	}
+
+	return contentType
+}
+
+// Ripped from https://github.com/gregjones/httpcache/blob/master/httpcache.go
+type cacheControl map[string]string
+
+func parseCacheControl(headers http.Header) cacheControl {
+	cc := cacheControl{}
+	ccHeader := headers.Get("Cache-Control")
+	for _, part := range strings.Split(ccHeader, ",") {
+		part = strings.Trim(part, " ")
+		if part == "" {
+			continue
+		}
+		if strings.ContainsRune(part, '=') {
+			keyval := strings.Split(part, "=")
+			cc[strings.Trim(keyval[0], " ")] = strings.Trim(keyval[1], ",")
+		} else {
+			cc[part] = ""
+		}
+	}
+	return cc
+}
+
+// CacheExpires helper function to determine remaining time before repeating a request.
+func CacheExpires(r *http.Response) time.Time {
+	// Figure out when the cache expires.
+	var expires time.Time
+	now, err := time.Parse(time.RFC1123, r.Header.Get("date"))
+	if err != nil {
+		return time.Now()
+	}
+	respCacheControl := parseCacheControl(r.Header)
+
+	if maxAge, ok := respCacheControl["max-age"]; ok {
+		lifetime, err := time.ParseDuration(maxAge + "s")
+		if err != nil {
+			expires = now
+		} else {
+			expires = now.Add(lifetime)
+		}
+	} else {
+		expiresHeader := r.Header.Get("Expires")
+		if expiresHeader != "" {
+			expires, err = time.Parse(time.RFC1123, expiresHeader)
+			if err != nil {
+				expires = now
+			}
+		}
+	}
+	return expires
+}
+
+func strlen(s string) int {
+	return utf8.RuneCountInString(s)
+}

pkg/certificatesbeta/configuration.go

@@ -0,0 +1,38 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+)
+
+// NewConfiguration returns a new Configuration object
+func NewConfiguration() *config.Configuration {
+	cfg := &config.Configuration{
+		DefaultHeader: make(map[string]string),
+		UserAgent:     "stackit-sdk-go/certificatesbeta",
+		Debug:         false,
+		Servers: config.ServerConfigurations{
+			{
+				URL:         "https://certificates.api.stackit.cloud",
+				Description: "No description provided",
+				Variables: map[string]config.ServerVariable{
+					"region": {
+						Description:  "No description provided",
+						DefaultValue: "global",
+					},
+				},
+			},
+		},
+		OperationServers: map[string]config.ServerConfigurations{},
+	}
+	return cfg
+}

pkg/certificatesbeta/model_create_certificate_payload.go

@@ -0,0 +1,325 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CreateCertificatePayload type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CreateCertificatePayload{}
+
+/*
+	types and functions for name
+*/
+
+// isNotNullableString
+type CreateCertificatePayloadGetNameAttributeType = *string
+
+func getCreateCertificatePayloadGetNameAttributeTypeOk(arg CreateCertificatePayloadGetNameAttributeType) (ret CreateCertificatePayloadGetNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificatePayloadGetNameAttributeType(arg *CreateCertificatePayloadGetNameAttributeType, val CreateCertificatePayloadGetNameRetType) {
+	*arg = &val
+}
+
+type CreateCertificatePayloadGetNameArgType = string
+type CreateCertificatePayloadGetNameRetType = string
+
+/*
+	types and functions for privateKey
+*/
+
+// isNotNullableString
+type CreateCertificatePayloadGetPrivateKeyAttributeType = *string
+
+func getCreateCertificatePayloadGetPrivateKeyAttributeTypeOk(arg CreateCertificatePayloadGetPrivateKeyAttributeType) (ret CreateCertificatePayloadGetPrivateKeyRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificatePayloadGetPrivateKeyAttributeType(arg *CreateCertificatePayloadGetPrivateKeyAttributeType, val CreateCertificatePayloadGetPrivateKeyRetType) {
+	*arg = &val
+}
+
+type CreateCertificatePayloadGetPrivateKeyArgType = string
+type CreateCertificatePayloadGetPrivateKeyRetType = string
+
+/*
+	types and functions for projectId
+*/
+
+// isNotNullableString
+type CreateCertificatePayloadGetProjectIdAttributeType = *string
+
+func getCreateCertificatePayloadGetProjectIdAttributeTypeOk(arg CreateCertificatePayloadGetProjectIdAttributeType) (ret CreateCertificatePayloadGetProjectIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificatePayloadGetProjectIdAttributeType(arg *CreateCertificatePayloadGetProjectIdAttributeType, val CreateCertificatePayloadGetProjectIdRetType) {
+	*arg = &val
+}
+
+type CreateCertificatePayloadGetProjectIdArgType = string
+type CreateCertificatePayloadGetProjectIdRetType = string
+
+/*
+	types and functions for publicKey
+*/
+
+// isNotNullableString
+type CreateCertificatePayloadGetPublicKeyAttributeType = *string
+
+func getCreateCertificatePayloadGetPublicKeyAttributeTypeOk(arg CreateCertificatePayloadGetPublicKeyAttributeType) (ret CreateCertificatePayloadGetPublicKeyRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificatePayloadGetPublicKeyAttributeType(arg *CreateCertificatePayloadGetPublicKeyAttributeType, val CreateCertificatePayloadGetPublicKeyRetType) {
+	*arg = &val
+}
+
+type CreateCertificatePayloadGetPublicKeyArgType = string
+type CreateCertificatePayloadGetPublicKeyRetType = string
+
+/*
+	types and functions for region
+*/
+
+// isNotNullableString
+type CreateCertificatePayloadGetRegionAttributeType = *string
+
+func getCreateCertificatePayloadGetRegionAttributeTypeOk(arg CreateCertificatePayloadGetRegionAttributeType) (ret CreateCertificatePayloadGetRegionRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificatePayloadGetRegionAttributeType(arg *CreateCertificatePayloadGetRegionAttributeType, val CreateCertificatePayloadGetRegionRetType) {
+	*arg = &val
+}
+
+type CreateCertificatePayloadGetRegionArgType = string
+type CreateCertificatePayloadGetRegionRetType = string
+
+// CreateCertificatePayload Uploads a PEM encoded X509 public/private key pair
+type CreateCertificatePayload struct {
+	// TLS certificate name
+	Name CreateCertificatePayloadGetNameAttributeType `json:"name,omitempty"`
+	// The PEM encoded private key part
+	PrivateKey CreateCertificatePayloadGetPrivateKeyAttributeType `json:"privateKey,omitempty"`
+	// Project identifier
+	ProjectId CreateCertificatePayloadGetProjectIdAttributeType `json:"projectId,omitempty"`
+	// The PEM encoded public key part
+	PublicKey CreateCertificatePayloadGetPublicKeyAttributeType `json:"publicKey,omitempty"`
+	// Region
+	Region CreateCertificatePayloadGetRegionAttributeType `json:"region,omitempty"`
+}
+
+// NewCreateCertificatePayload instantiates a new CreateCertificatePayload object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewCreateCertificatePayload() *CreateCertificatePayload {
+	this := CreateCertificatePayload{}
+	return &this
+}
+
+// NewCreateCertificatePayloadWithDefaults instantiates a new CreateCertificatePayload object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewCreateCertificatePayloadWithDefaults() *CreateCertificatePayload {
+	this := CreateCertificatePayload{}
+	return &this
+}
+
+// GetName returns the Name field value if set, zero value otherwise.
+func (o *CreateCertificatePayload) GetName() (res CreateCertificatePayloadGetNameRetType) {
+	res, _ = o.GetNameOk()
+	return
+}
+
+// GetNameOk returns a tuple with the Name field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificatePayload) GetNameOk() (ret CreateCertificatePayloadGetNameRetType, ok bool) {
+	return getCreateCertificatePayloadGetNameAttributeTypeOk(o.Name)
+}
+
+// HasName returns a boolean if a field has been set.
+func (o *CreateCertificatePayload) HasName() bool {
+	_, ok := o.GetNameOk()
+	return ok
+}
+
+// SetName gets a reference to the given string and assigns it to the Name field.
+func (o *CreateCertificatePayload) SetName(v CreateCertificatePayloadGetNameRetType) {
+	setCreateCertificatePayloadGetNameAttributeType(&o.Name, v)
+}
+
+// GetPrivateKey returns the PrivateKey field value if set, zero value otherwise.
+func (o *CreateCertificatePayload) GetPrivateKey() (res CreateCertificatePayloadGetPrivateKeyRetType) {
+	res, _ = o.GetPrivateKeyOk()
+	return
+}
+
+// GetPrivateKeyOk returns a tuple with the PrivateKey field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificatePayload) GetPrivateKeyOk() (ret CreateCertificatePayloadGetPrivateKeyRetType, ok bool) {
+	return getCreateCertificatePayloadGetPrivateKeyAttributeTypeOk(o.PrivateKey)
+}
+
+// HasPrivateKey returns a boolean if a field has been set.
+func (o *CreateCertificatePayload) HasPrivateKey() bool {
+	_, ok := o.GetPrivateKeyOk()
+	return ok
+}
+
+// SetPrivateKey gets a reference to the given string and assigns it to the PrivateKey field.
+func (o *CreateCertificatePayload) SetPrivateKey(v CreateCertificatePayloadGetPrivateKeyRetType) {
+	setCreateCertificatePayloadGetPrivateKeyAttributeType(&o.PrivateKey, v)
+}
+
+// GetProjectId returns the ProjectId field value if set, zero value otherwise.
+func (o *CreateCertificatePayload) GetProjectId() (res CreateCertificatePayloadGetProjectIdRetType) {
+	res, _ = o.GetProjectIdOk()
+	return
+}
+
+// GetProjectIdOk returns a tuple with the ProjectId field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificatePayload) GetProjectIdOk() (ret CreateCertificatePayloadGetProjectIdRetType, ok bool) {
+	return getCreateCertificatePayloadGetProjectIdAttributeTypeOk(o.ProjectId)
+}
+
+// HasProjectId returns a boolean if a field has been set.
+func (o *CreateCertificatePayload) HasProjectId() bool {
+	_, ok := o.GetProjectIdOk()
+	return ok
+}
+
+// SetProjectId gets a reference to the given string and assigns it to the ProjectId field.
+func (o *CreateCertificatePayload) SetProjectId(v CreateCertificatePayloadGetProjectIdRetType) {
+	setCreateCertificatePayloadGetProjectIdAttributeType(&o.ProjectId, v)
+}
+
+// GetPublicKey returns the PublicKey field value if set, zero value otherwise.
+func (o *CreateCertificatePayload) GetPublicKey() (res CreateCertificatePayloadGetPublicKeyRetType) {
+	res, _ = o.GetPublicKeyOk()
+	return
+}
+
+// GetPublicKeyOk returns a tuple with the PublicKey field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificatePayload) GetPublicKeyOk() (ret CreateCertificatePayloadGetPublicKeyRetType, ok bool) {
+	return getCreateCertificatePayloadGetPublicKeyAttributeTypeOk(o.PublicKey)
+}
+
+// HasPublicKey returns a boolean if a field has been set.
+func (o *CreateCertificatePayload) HasPublicKey() bool {
+	_, ok := o.GetPublicKeyOk()
+	return ok
+}
+
+// SetPublicKey gets a reference to the given string and assigns it to the PublicKey field.
+func (o *CreateCertificatePayload) SetPublicKey(v CreateCertificatePayloadGetPublicKeyRetType) {
+	setCreateCertificatePayloadGetPublicKeyAttributeType(&o.PublicKey, v)
+}
+
+// GetRegion returns the Region field value if set, zero value otherwise.
+func (o *CreateCertificatePayload) GetRegion() (res CreateCertificatePayloadGetRegionRetType) {
+	res, _ = o.GetRegionOk()
+	return
+}
+
+// GetRegionOk returns a tuple with the Region field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificatePayload) GetRegionOk() (ret CreateCertificatePayloadGetRegionRetType, ok bool) {
+	return getCreateCertificatePayloadGetRegionAttributeTypeOk(o.Region)
+}
+
+// HasRegion returns a boolean if a field has been set.
+func (o *CreateCertificatePayload) HasRegion() bool {
+	_, ok := o.GetRegionOk()
+	return ok
+}
+
+// SetRegion gets a reference to the given string and assigns it to the Region field.
+func (o *CreateCertificatePayload) SetRegion(v CreateCertificatePayloadGetRegionRetType) {
+	setCreateCertificatePayloadGetRegionAttributeType(&o.Region, v)
+}
+
+func (o CreateCertificatePayload) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCreateCertificatePayloadGetNameAttributeTypeOk(o.Name); ok {
+		toSerialize["Name"] = val
+	}
+	if val, ok := getCreateCertificatePayloadGetPrivateKeyAttributeTypeOk(o.PrivateKey); ok {
+		toSerialize["PrivateKey"] = val
+	}
+	if val, ok := getCreateCertificatePayloadGetProjectIdAttributeTypeOk(o.ProjectId); ok {
+		toSerialize["ProjectId"] = val
+	}
+	if val, ok := getCreateCertificatePayloadGetPublicKeyAttributeTypeOk(o.PublicKey); ok {
+		toSerialize["PublicKey"] = val
+	}
+	if val, ok := getCreateCertificatePayloadGetRegionAttributeTypeOk(o.Region); ok {
+		toSerialize["Region"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCreateCertificatePayload struct {
+	value *CreateCertificatePayload
+	isSet bool
+}
+
+func (v NullableCreateCertificatePayload) Get() *CreateCertificatePayload {
+	return v.value
+}
+
+func (v *NullableCreateCertificatePayload) Set(val *CreateCertificatePayload) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCreateCertificatePayload) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCreateCertificatePayload) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCreateCertificatePayload(val *CreateCertificatePayload) *NullableCreateCertificatePayload {
+	return &NullableCreateCertificatePayload{value: val, isSet: true}
+}
+
+func (v NullableCreateCertificatePayload) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCreateCertificatePayload) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_create_certificate_payload_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/model_create_certificate_response.go

@@ -0,0 +1,178 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CreateCertificateResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CreateCertificateResponse{}
+
+/*
+	types and functions for id
+*/
+
+// isNotNullableString
+type CreateCertificateResponseGetIdAttributeType = *string
+
+func getCreateCertificateResponseGetIdAttributeTypeOk(arg CreateCertificateResponseGetIdAttributeType) (ret CreateCertificateResponseGetIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificateResponseGetIdAttributeType(arg *CreateCertificateResponseGetIdAttributeType, val CreateCertificateResponseGetIdRetType) {
+	*arg = &val
+}
+
+type CreateCertificateResponseGetIdArgType = string
+type CreateCertificateResponseGetIdRetType = string
+
+/*
+	types and functions for region
+*/
+
+// isNotNullableString
+type CreateCertificateResponseGetRegionAttributeType = *string
+
+func getCreateCertificateResponseGetRegionAttributeTypeOk(arg CreateCertificateResponseGetRegionAttributeType) (ret CreateCertificateResponseGetRegionRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCertificateResponseGetRegionAttributeType(arg *CreateCertificateResponseGetRegionAttributeType, val CreateCertificateResponseGetRegionRetType) {
+	*arg = &val
+}
+
+type CreateCertificateResponseGetRegionArgType = string
+type CreateCertificateResponseGetRegionRetType = string
+
+// CreateCertificateResponse CreateCertificateResponse returns unique resource id
+type CreateCertificateResponse struct {
+	// The certificates resource id
+	Id CreateCertificateResponseGetIdAttributeType `json:"id,omitempty"`
+	// Region
+	Region CreateCertificateResponseGetRegionAttributeType `json:"region,omitempty"`
+}
+
+// NewCreateCertificateResponse instantiates a new CreateCertificateResponse object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewCreateCertificateResponse() *CreateCertificateResponse {
+	this := CreateCertificateResponse{}
+	return &this
+}
+
+// NewCreateCertificateResponseWithDefaults instantiates a new CreateCertificateResponse object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewCreateCertificateResponseWithDefaults() *CreateCertificateResponse {
+	this := CreateCertificateResponse{}
+	return &this
+}
+
+// GetId returns the Id field value if set, zero value otherwise.
+func (o *CreateCertificateResponse) GetId() (res CreateCertificateResponseGetIdRetType) {
+	res, _ = o.GetIdOk()
+	return
+}
+
+// GetIdOk returns a tuple with the Id field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificateResponse) GetIdOk() (ret CreateCertificateResponseGetIdRetType, ok bool) {
+	return getCreateCertificateResponseGetIdAttributeTypeOk(o.Id)
+}
+
+// HasId returns a boolean if a field has been set.
+func (o *CreateCertificateResponse) HasId() bool {
+	_, ok := o.GetIdOk()
+	return ok
+}
+
+// SetId gets a reference to the given string and assigns it to the Id field.
+func (o *CreateCertificateResponse) SetId(v CreateCertificateResponseGetIdRetType) {
+	setCreateCertificateResponseGetIdAttributeType(&o.Id, v)
+}
+
+// GetRegion returns the Region field value if set, zero value otherwise.
+func (o *CreateCertificateResponse) GetRegion() (res CreateCertificateResponseGetRegionRetType) {
+	res, _ = o.GetRegionOk()
+	return
+}
+
+// GetRegionOk returns a tuple with the Region field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCertificateResponse) GetRegionOk() (ret CreateCertificateResponseGetRegionRetType, ok bool) {
+	return getCreateCertificateResponseGetRegionAttributeTypeOk(o.Region)
+}
+
+// HasRegion returns a boolean if a field has been set.
+func (o *CreateCertificateResponse) HasRegion() bool {
+	_, ok := o.GetRegionOk()
+	return ok
+}
+
+// SetRegion gets a reference to the given string and assigns it to the Region field.
+func (o *CreateCertificateResponse) SetRegion(v CreateCertificateResponseGetRegionRetType) {
+	setCreateCertificateResponseGetRegionAttributeType(&o.Region, v)
+}
+
+func (o CreateCertificateResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCreateCertificateResponseGetIdAttributeTypeOk(o.Id); ok {
+		toSerialize["Id"] = val
+	}
+	if val, ok := getCreateCertificateResponseGetRegionAttributeTypeOk(o.Region); ok {
+		toSerialize["Region"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCreateCertificateResponse struct {
+	value *CreateCertificateResponse
+	isSet bool
+}
+
+func (v NullableCreateCertificateResponse) Get() *CreateCertificateResponse {
+	return v.value
+}
+
+func (v *NullableCreateCertificateResponse) Set(val *CreateCertificateResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCreateCertificateResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCreateCertificateResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCreateCertificateResponse(val *CreateCertificateResponse) *NullableCreateCertificateResponse {
+	return &NullableCreateCertificateResponse{value: val, isSet: true}
+}
+
+func (v NullableCreateCertificateResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCreateCertificateResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_create_certificate_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/model_get_certificate_response.go

@@ -0,0 +1,276 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the GetCertificateResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &GetCertificateResponse{}
+
+/*
+	types and functions for id
+*/
+
+// isNotNullableString
+type GetCertificateResponseGetIdAttributeType = *string
+
+func getGetCertificateResponseGetIdAttributeTypeOk(arg GetCertificateResponseGetIdAttributeType) (ret GetCertificateResponseGetIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGetCertificateResponseGetIdAttributeType(arg *GetCertificateResponseGetIdAttributeType, val GetCertificateResponseGetIdRetType) {
+	*arg = &val
+}
+
+type GetCertificateResponseGetIdArgType = string
+type GetCertificateResponseGetIdRetType = string
+
+/*
+	types and functions for name
+*/
+
+// isNotNullableString
+type GetCertificateResponseGetNameAttributeType = *string
+
+func getGetCertificateResponseGetNameAttributeTypeOk(arg GetCertificateResponseGetNameAttributeType) (ret GetCertificateResponseGetNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGetCertificateResponseGetNameAttributeType(arg *GetCertificateResponseGetNameAttributeType, val GetCertificateResponseGetNameRetType) {
+	*arg = &val
+}
+
+type GetCertificateResponseGetNameArgType = string
+type GetCertificateResponseGetNameRetType = string
+
+/*
+	types and functions for publicKey
+*/
+
+// isNotNullableString
+type GetCertificateResponseGetPublicKeyAttributeType = *string
+
+func getGetCertificateResponseGetPublicKeyAttributeTypeOk(arg GetCertificateResponseGetPublicKeyAttributeType) (ret GetCertificateResponseGetPublicKeyRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGetCertificateResponseGetPublicKeyAttributeType(arg *GetCertificateResponseGetPublicKeyAttributeType, val GetCertificateResponseGetPublicKeyRetType) {
+	*arg = &val
+}
+
+type GetCertificateResponseGetPublicKeyArgType = string
+type GetCertificateResponseGetPublicKeyRetType = string
+
+/*
+	types and functions for region
+*/
+
+// isNotNullableString
+type GetCertificateResponseGetRegionAttributeType = *string
+
+func getGetCertificateResponseGetRegionAttributeTypeOk(arg GetCertificateResponseGetRegionAttributeType) (ret GetCertificateResponseGetRegionRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGetCertificateResponseGetRegionAttributeType(arg *GetCertificateResponseGetRegionAttributeType, val GetCertificateResponseGetRegionRetType) {
+	*arg = &val
+}
+
+type GetCertificateResponseGetRegionArgType = string
+type GetCertificateResponseGetRegionRetType = string
+
+// GetCertificateResponse GetCertificateResponse returns name, id and public key
+type GetCertificateResponse struct {
+	// The certificates resource id
+	Id GetCertificateResponseGetIdAttributeType `json:"id,omitempty"`
+	// TLS certificate name
+	Name GetCertificateResponseGetNameAttributeType `json:"name,omitempty"`
+	// The PEM encoded public key part
+	PublicKey GetCertificateResponseGetPublicKeyAttributeType `json:"publicKey,omitempty"`
+	// Region of the LoadBalancer
+	Region GetCertificateResponseGetRegionAttributeType `json:"region,omitempty"`
+}
+
+// NewGetCertificateResponse instantiates a new GetCertificateResponse object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewGetCertificateResponse() *GetCertificateResponse {
+	this := GetCertificateResponse{}
+	return &this
+}
+
+// NewGetCertificateResponseWithDefaults instantiates a new GetCertificateResponse object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewGetCertificateResponseWithDefaults() *GetCertificateResponse {
+	this := GetCertificateResponse{}
+	return &this
+}
+
+// GetId returns the Id field value if set, zero value otherwise.
+func (o *GetCertificateResponse) GetId() (res GetCertificateResponseGetIdRetType) {
+	res, _ = o.GetIdOk()
+	return
+}
+
+// GetIdOk returns a tuple with the Id field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *GetCertificateResponse) GetIdOk() (ret GetCertificateResponseGetIdRetType, ok bool) {
+	return getGetCertificateResponseGetIdAttributeTypeOk(o.Id)
+}
+
+// HasId returns a boolean if a field has been set.
+func (o *GetCertificateResponse) HasId() bool {
+	_, ok := o.GetIdOk()
+	return ok
+}
+
+// SetId gets a reference to the given string and assigns it to the Id field.
+func (o *GetCertificateResponse) SetId(v GetCertificateResponseGetIdRetType) {
+	setGetCertificateResponseGetIdAttributeType(&o.Id, v)
+}
+
+// GetName returns the Name field value if set, zero value otherwise.
+func (o *GetCertificateResponse) GetName() (res GetCertificateResponseGetNameRetType) {
+	res, _ = o.GetNameOk()
+	return
+}
+
+// GetNameOk returns a tuple with the Name field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *GetCertificateResponse) GetNameOk() (ret GetCertificateResponseGetNameRetType, ok bool) {
+	return getGetCertificateResponseGetNameAttributeTypeOk(o.Name)
+}
+
+// HasName returns a boolean if a field has been set.
+func (o *GetCertificateResponse) HasName() bool {
+	_, ok := o.GetNameOk()
+	return ok
+}
+
+// SetName gets a reference to the given string and assigns it to the Name field.
+func (o *GetCertificateResponse) SetName(v GetCertificateResponseGetNameRetType) {
+	setGetCertificateResponseGetNameAttributeType(&o.Name, v)
+}
+
+// GetPublicKey returns the PublicKey field value if set, zero value otherwise.
+func (o *GetCertificateResponse) GetPublicKey() (res GetCertificateResponseGetPublicKeyRetType) {
+	res, _ = o.GetPublicKeyOk()
+	return
+}
+
+// GetPublicKeyOk returns a tuple with the PublicKey field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *GetCertificateResponse) GetPublicKeyOk() (ret GetCertificateResponseGetPublicKeyRetType, ok bool) {
+	return getGetCertificateResponseGetPublicKeyAttributeTypeOk(o.PublicKey)
+}
+
+// HasPublicKey returns a boolean if a field has been set.
+func (o *GetCertificateResponse) HasPublicKey() bool {
+	_, ok := o.GetPublicKeyOk()
+	return ok
+}
+
+// SetPublicKey gets a reference to the given string and assigns it to the PublicKey field.
+func (o *GetCertificateResponse) SetPublicKey(v GetCertificateResponseGetPublicKeyRetType) {
+	setGetCertificateResponseGetPublicKeyAttributeType(&o.PublicKey, v)
+}
+
+// GetRegion returns the Region field value if set, zero value otherwise.
+func (o *GetCertificateResponse) GetRegion() (res GetCertificateResponseGetRegionRetType) {
+	res, _ = o.GetRegionOk()
+	return
+}
+
+// GetRegionOk returns a tuple with the Region field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *GetCertificateResponse) GetRegionOk() (ret GetCertificateResponseGetRegionRetType, ok bool) {
+	return getGetCertificateResponseGetRegionAttributeTypeOk(o.Region)
+}
+
+// HasRegion returns a boolean if a field has been set.
+func (o *GetCertificateResponse) HasRegion() bool {
+	_, ok := o.GetRegionOk()
+	return ok
+}
+
+// SetRegion gets a reference to the given string and assigns it to the Region field.
+func (o *GetCertificateResponse) SetRegion(v GetCertificateResponseGetRegionRetType) {
+	setGetCertificateResponseGetRegionAttributeType(&o.Region, v)
+}
+
+func (o GetCertificateResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getGetCertificateResponseGetIdAttributeTypeOk(o.Id); ok {
+		toSerialize["Id"] = val
+	}
+	if val, ok := getGetCertificateResponseGetNameAttributeTypeOk(o.Name); ok {
+		toSerialize["Name"] = val
+	}
+	if val, ok := getGetCertificateResponseGetPublicKeyAttributeTypeOk(o.PublicKey); ok {
+		toSerialize["PublicKey"] = val
+	}
+	if val, ok := getGetCertificateResponseGetRegionAttributeTypeOk(o.Region); ok {
+		toSerialize["Region"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableGetCertificateResponse struct {
+	value *GetCertificateResponse
+	isSet bool
+}
+
+func (v NullableGetCertificateResponse) Get() *GetCertificateResponse {
+	return v.value
+}
+
+func (v *NullableGetCertificateResponse) Set(val *GetCertificateResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableGetCertificateResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableGetCertificateResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableGetCertificateResponse(val *GetCertificateResponse) *NullableGetCertificateResponse {
+	return &NullableGetCertificateResponse{value: val, isSet: true}
+}
+
+func (v NullableGetCertificateResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableGetCertificateResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_get_certificate_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/model_google_protobuf_any.go

@@ -0,0 +1,137 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the GoogleProtobufAny type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &GoogleProtobufAny{}
+
+/*
+	types and functions for @type
+*/
+
+// isNotNullableString
+type GoogleProtobufAnyGetTypeAttributeType = *string
+
+func getGoogleProtobufAnyGetTypeAttributeTypeOk(arg GoogleProtobufAnyGetTypeAttributeType) (ret GoogleProtobufAnyGetTypeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGoogleProtobufAnyGetTypeAttributeType(arg *GoogleProtobufAnyGetTypeAttributeType, val GoogleProtobufAnyGetTypeRetType) {
+	*arg = &val
+}
+
+type GoogleProtobufAnyGetTypeArgType = string
+type GoogleProtobufAnyGetTypeRetType = string
+
+// GoogleProtobufAny Contains an arbitrary serialized message along with a @type that describes the type of the serialized message.
+type GoogleProtobufAny struct {
+	// The type of the serialized message.
+	Type                 GoogleProtobufAnyGetTypeAttributeType `json:"@type,omitempty"`
+	AdditionalProperties map[string]interface{}
+}
+
+type _GoogleProtobufAny GoogleProtobufAny
+
+// NewGoogleProtobufAny instantiates a new GoogleProtobufAny object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewGoogleProtobufAny() *GoogleProtobufAny {
+	this := GoogleProtobufAny{}
+	return &this
+}
+
+// NewGoogleProtobufAnyWithDefaults instantiates a new GoogleProtobufAny object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewGoogleProtobufAnyWithDefaults() *GoogleProtobufAny {
+	this := GoogleProtobufAny{}
+	return &this
+}
+
+// GetType returns the Type field value if set, zero value otherwise.
+func (o *GoogleProtobufAny) GetType() (res GoogleProtobufAnyGetTypeRetType) {
+	res, _ = o.GetTypeOk()
+	return
+}
+
+// GetTypeOk returns a tuple with the Type field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *GoogleProtobufAny) GetTypeOk() (ret GoogleProtobufAnyGetTypeRetType, ok bool) {
+	return getGoogleProtobufAnyGetTypeAttributeTypeOk(o.Type)
+}
+
+// HasType returns a boolean if a field has been set.
+func (o *GoogleProtobufAny) HasType() bool {
+	_, ok := o.GetTypeOk()
+	return ok
+}
+
+// SetType gets a reference to the given string and assigns it to the Type field.
+func (o *GoogleProtobufAny) SetType(v GoogleProtobufAnyGetTypeRetType) {
+	setGoogleProtobufAnyGetTypeAttributeType(&o.Type, v)
+}
+
+func (o GoogleProtobufAny) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getGoogleProtobufAnyGetTypeAttributeTypeOk(o.Type); ok {
+		toSerialize["Type"] = val
+	}
+
+	for key, value := range o.AdditionalProperties {
+		toSerialize[key] = value
+	}
+
+	return toSerialize, nil
+}
+
+type NullableGoogleProtobufAny struct {
+	value *GoogleProtobufAny
+	isSet bool
+}
+
+func (v NullableGoogleProtobufAny) Get() *GoogleProtobufAny {
+	return v.value
+}
+
+func (v *NullableGoogleProtobufAny) Set(val *GoogleProtobufAny) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableGoogleProtobufAny) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableGoogleProtobufAny) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableGoogleProtobufAny(val *GoogleProtobufAny) *NullableGoogleProtobufAny {
+	return &NullableGoogleProtobufAny{value: val, isSet: true}
+}
+
+func (v NullableGoogleProtobufAny) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableGoogleProtobufAny) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_google_protobuf_any_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/model_list_certificates_response.go

@@ -0,0 +1,176 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the ListCertificatesResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &ListCertificatesResponse{}
+
+/*
+	types and functions for items
+*/
+
+// isArray
+type ListCertificatesResponseGetItemsAttributeType = *[]GetCertificateResponse
+type ListCertificatesResponseGetItemsArgType = []GetCertificateResponse
+type ListCertificatesResponseGetItemsRetType = []GetCertificateResponse
+
+func getListCertificatesResponseGetItemsAttributeTypeOk(arg ListCertificatesResponseGetItemsAttributeType) (ret ListCertificatesResponseGetItemsRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setListCertificatesResponseGetItemsAttributeType(arg *ListCertificatesResponseGetItemsAttributeType, val ListCertificatesResponseGetItemsRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for nextPageId
+*/
+
+// isNotNullableString
+type ListCertificatesResponseGetNextPageIdAttributeType = *string
+
+func getListCertificatesResponseGetNextPageIdAttributeTypeOk(arg ListCertificatesResponseGetNextPageIdAttributeType) (ret ListCertificatesResponseGetNextPageIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setListCertificatesResponseGetNextPageIdAttributeType(arg *ListCertificatesResponseGetNextPageIdAttributeType, val ListCertificatesResponseGetNextPageIdRetType) {
+	*arg = &val
+}
+
+type ListCertificatesResponseGetNextPageIdArgType = string
+type ListCertificatesResponseGetNextPageIdRetType = string
+
+// ListCertificatesResponse ListCertificateResponse returns a list of certificate responses
+type ListCertificatesResponse struct {
+	Items ListCertificatesResponseGetItemsAttributeType `json:"items,omitempty"`
+	// Continue token from the ListCertificatesResponse with Limit option
+	NextPageId ListCertificatesResponseGetNextPageIdAttributeType `json:"nextPageId,omitempty"`
+}
+
+// NewListCertificatesResponse instantiates a new ListCertificatesResponse object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewListCertificatesResponse() *ListCertificatesResponse {
+	this := ListCertificatesResponse{}
+	return &this
+}
+
+// NewListCertificatesResponseWithDefaults instantiates a new ListCertificatesResponse object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewListCertificatesResponseWithDefaults() *ListCertificatesResponse {
+	this := ListCertificatesResponse{}
+	return &this
+}
+
+// GetItems returns the Items field value if set, zero value otherwise.
+func (o *ListCertificatesResponse) GetItems() (res ListCertificatesResponseGetItemsRetType) {
+	res, _ = o.GetItemsOk()
+	return
+}
+
+// GetItemsOk returns a tuple with the Items field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *ListCertificatesResponse) GetItemsOk() (ret ListCertificatesResponseGetItemsRetType, ok bool) {
+	return getListCertificatesResponseGetItemsAttributeTypeOk(o.Items)
+}
+
+// HasItems returns a boolean if a field has been set.
+func (o *ListCertificatesResponse) HasItems() bool {
+	_, ok := o.GetItemsOk()
+	return ok
+}
+
+// SetItems gets a reference to the given []GetCertificateResponse and assigns it to the Items field.
+func (o *ListCertificatesResponse) SetItems(v ListCertificatesResponseGetItemsRetType) {
+	setListCertificatesResponseGetItemsAttributeType(&o.Items, v)
+}
+
+// GetNextPageId returns the NextPageId field value if set, zero value otherwise.
+func (o *ListCertificatesResponse) GetNextPageId() (res ListCertificatesResponseGetNextPageIdRetType) {
+	res, _ = o.GetNextPageIdOk()
+	return
+}
+
+// GetNextPageIdOk returns a tuple with the NextPageId field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *ListCertificatesResponse) GetNextPageIdOk() (ret ListCertificatesResponseGetNextPageIdRetType, ok bool) {
+	return getListCertificatesResponseGetNextPageIdAttributeTypeOk(o.NextPageId)
+}
+
+// HasNextPageId returns a boolean if a field has been set.
+func (o *ListCertificatesResponse) HasNextPageId() bool {
+	_, ok := o.GetNextPageIdOk()
+	return ok
+}
+
+// SetNextPageId gets a reference to the given string and assigns it to the NextPageId field.
+func (o *ListCertificatesResponse) SetNextPageId(v ListCertificatesResponseGetNextPageIdRetType) {
+	setListCertificatesResponseGetNextPageIdAttributeType(&o.NextPageId, v)
+}
+
+func (o ListCertificatesResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getListCertificatesResponseGetItemsAttributeTypeOk(o.Items); ok {
+		toSerialize["Items"] = val
+	}
+	if val, ok := getListCertificatesResponseGetNextPageIdAttributeTypeOk(o.NextPageId); ok {
+		toSerialize["NextPageId"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableListCertificatesResponse struct {
+	value *ListCertificatesResponse
+	isSet bool
+}
+
+func (v NullableListCertificatesResponse) Get() *ListCertificatesResponse {
+	return v.value
+}
+
+func (v *NullableListCertificatesResponse) Set(val *ListCertificatesResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableListCertificatesResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableListCertificatesResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableListCertificatesResponse(val *ListCertificatesResponse) *NullableListCertificatesResponse {
+	return &NullableListCertificatesResponse{value: val, isSet: true}
+}
+
+func (v NullableListCertificatesResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableListCertificatesResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_list_certificates_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/model_status.go

@@ -0,0 +1,226 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the Status type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &Status{}
+
+/*
+	types and functions for code
+*/
+
+// isInteger
+type StatusGetCodeAttributeType = *int64
+type StatusGetCodeArgType = int64
+type StatusGetCodeRetType = int64
+
+func getStatusGetCodeAttributeTypeOk(arg StatusGetCodeAttributeType) (ret StatusGetCodeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setStatusGetCodeAttributeType(arg *StatusGetCodeAttributeType, val StatusGetCodeRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for details
+*/
+
+// isArray
+type StatusGetDetailsAttributeType = *[]GoogleProtobufAny
+type StatusGetDetailsArgType = []GoogleProtobufAny
+type StatusGetDetailsRetType = []GoogleProtobufAny
+
+func getStatusGetDetailsAttributeTypeOk(arg StatusGetDetailsAttributeType) (ret StatusGetDetailsRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setStatusGetDetailsAttributeType(arg *StatusGetDetailsAttributeType, val StatusGetDetailsRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for message
+*/
+
+// isNotNullableString
+type StatusGetMessageAttributeType = *string
+
+func getStatusGetMessageAttributeTypeOk(arg StatusGetMessageAttributeType) (ret StatusGetMessageRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setStatusGetMessageAttributeType(arg *StatusGetMessageAttributeType, val StatusGetMessageRetType) {
+	*arg = &val
+}
+
+type StatusGetMessageArgType = string
+type StatusGetMessageRetType = string
+
+// Status The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
+type Status struct {
+	// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+	// Can be cast to int32 without loss of precision.
+	Code StatusGetCodeAttributeType `json:"code,omitempty"`
+	// A list of messages that carry the error details.  There is a common set of message types for APIs to use.
+	Details StatusGetDetailsAttributeType `json:"details,omitempty"`
+	// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+	Message StatusGetMessageAttributeType `json:"message,omitempty"`
+}
+
+// NewStatus instantiates a new Status object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewStatus() *Status {
+	this := Status{}
+	return &this
+}
+
+// NewStatusWithDefaults instantiates a new Status object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewStatusWithDefaults() *Status {
+	this := Status{}
+	return &this
+}
+
+// GetCode returns the Code field value if set, zero value otherwise.
+func (o *Status) GetCode() (res StatusGetCodeRetType) {
+	res, _ = o.GetCodeOk()
+	return
+}
+
+// GetCodeOk returns a tuple with the Code field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Status) GetCodeOk() (ret StatusGetCodeRetType, ok bool) {
+	return getStatusGetCodeAttributeTypeOk(o.Code)
+}
+
+// HasCode returns a boolean if a field has been set.
+func (o *Status) HasCode() bool {
+	_, ok := o.GetCodeOk()
+	return ok
+}
+
+// SetCode gets a reference to the given int64 and assigns it to the Code field.
+func (o *Status) SetCode(v StatusGetCodeRetType) {
+	setStatusGetCodeAttributeType(&o.Code, v)
+}
+
+// GetDetails returns the Details field value if set, zero value otherwise.
+func (o *Status) GetDetails() (res StatusGetDetailsRetType) {
+	res, _ = o.GetDetailsOk()
+	return
+}
+
+// GetDetailsOk returns a tuple with the Details field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Status) GetDetailsOk() (ret StatusGetDetailsRetType, ok bool) {
+	return getStatusGetDetailsAttributeTypeOk(o.Details)
+}
+
+// HasDetails returns a boolean if a field has been set.
+func (o *Status) HasDetails() bool {
+	_, ok := o.GetDetailsOk()
+	return ok
+}
+
+// SetDetails gets a reference to the given []GoogleProtobufAny and assigns it to the Details field.
+func (o *Status) SetDetails(v StatusGetDetailsRetType) {
+	setStatusGetDetailsAttributeType(&o.Details, v)
+}
+
+// GetMessage returns the Message field value if set, zero value otherwise.
+func (o *Status) GetMessage() (res StatusGetMessageRetType) {
+	res, _ = o.GetMessageOk()
+	return
+}
+
+// GetMessageOk returns a tuple with the Message field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Status) GetMessageOk() (ret StatusGetMessageRetType, ok bool) {
+	return getStatusGetMessageAttributeTypeOk(o.Message)
+}
+
+// HasMessage returns a boolean if a field has been set.
+func (o *Status) HasMessage() bool {
+	_, ok := o.GetMessageOk()
+	return ok
+}
+
+// SetMessage gets a reference to the given string and assigns it to the Message field.
+func (o *Status) SetMessage(v StatusGetMessageRetType) {
+	setStatusGetMessageAttributeType(&o.Message, v)
+}
+
+func (o Status) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getStatusGetCodeAttributeTypeOk(o.Code); ok {
+		toSerialize["Code"] = val
+	}
+	if val, ok := getStatusGetDetailsAttributeTypeOk(o.Details); ok {
+		toSerialize["Details"] = val
+	}
+	if val, ok := getStatusGetMessageAttributeTypeOk(o.Message); ok {
+		toSerialize["Message"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableStatus struct {
+	value *Status
+	isSet bool
+}
+
+func (v NullableStatus) Get() *Status {
+	return v.value
+}
+
+func (v *NullableStatus) Set(val *Status) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableStatus) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableStatus) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableStatus(val *Status) *NullableStatus {
+	return &NullableStatus{value: val, isSet: true}
+}
+
+func (v NullableStatus) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableStatus) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/certificatesbeta/model_status_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta

pkg/certificatesbeta/utils.go

@@ -0,0 +1,385 @@
+/*
+STACKIT Application Load Balancer Certificates API
+
+### DEPRECATED! This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server.
+
+API version: 2beta.0.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package certificatesbeta
+
+import (
+	"encoding/json"
+	"math/rand"
+	"reflect"
+	"time"
+)
+
+// PtrBool is a helper routine that returns a pointer to given boolean value.
+func PtrBool(v bool) *bool { return &v }
+
+// PtrInt is a helper routine that returns a pointer to given integer value.
+func PtrInt(v int) *int { return &v }
+
+// PtrInt32 is a helper routine that returns a pointer to given integer value.
+func PtrInt32(v int32) *int32 { return &v }
+
+// PtrInt64 is a helper routine that returns a pointer to given integer value.
+func PtrInt64(v int64) *int64 { return &v }
+
+// PtrFloat32 is a helper routine that returns a pointer to given float value.
+func PtrFloat32(v float32) *float32 { return &v }
+
+// PtrFloat64 is a helper routine that returns a pointer to given float value.
+func PtrFloat64(v float64) *float64 { return &v }
+
+// PtrString is a helper routine that returns a pointer to given string value.
+func PtrString(v string) *string { return &v }
+
+// PtrTime is helper routine that returns a pointer to given Time value.
+func PtrTime(v time.Time) *time.Time { return &v }
+
+type NullableValue[T any] struct {
+	value *T
+	isSet bool
+}
+
+func (v NullableValue[T]) Get() *T {
+	return v.value
+}
+
+func (v *NullableValue[T]) Set(val *T) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableValue[T]) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableValue[T]) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+type NullableBool struct {
+	value *bool
+	isSet bool
+}
+
+func (v NullableBool) Get() *bool {
+	return v.value
+}
+
+func (v *NullableBool) Set(val *bool) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableBool) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableBool) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableBool(val *bool) *NullableBool {
+	return &NullableBool{value: val, isSet: true}
+}
+
+func (v NullableBool) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableBool) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableInt struct {
+	value *int
+	isSet bool
+}
+
+func (v NullableInt) Get() *int {
+	return v.value
+}
+
+func (v *NullableInt) Set(val *int) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableInt) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableInt) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableInt(val *int) *NullableInt {
+	return &NullableInt{value: val, isSet: true}
+}
+
+func (v NullableInt) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableInt) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableInt32 struct {
+	value *int32
+	isSet bool
+}
+
+func (v NullableInt32) Get() *int32 {
+	return v.value
+}
+
+func (v *NullableInt32) Set(val *int32) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableInt32) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableInt32) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableInt32(val *int32) *NullableInt32 {
+	return &NullableInt32{value: val, isSet: true}
+}
+
+func (v NullableInt32) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableInt32) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableInt64 struct {
+	value *int64
+	isSet bool
+}
+
+func (v NullableInt64) Get() *int64 {
+	return v.value
+}
+
+func (v *NullableInt64) Set(val *int64) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableInt64) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableInt64) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableInt64(val *int64) *NullableInt64 {
+	return &NullableInt64{value: val, isSet: true}
+}
+
+func (v NullableInt64) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableInt64) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableFloat32 struct {
+	value *float32
+	isSet bool
+}
+
+func (v NullableFloat32) Get() *float32 {
+	return v.value
+}
+
+func (v *NullableFloat32) Set(val *float32) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableFloat32) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableFloat32) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableFloat32(val *float32) *NullableFloat32 {
+	return &NullableFloat32{value: val, isSet: true}
+}
+
+func (v NullableFloat32) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableFloat32) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableFloat64 struct {
+	value *float64
+	isSet bool
+}
+
+func (v NullableFloat64) Get() *float64 {
+	return v.value
+}
+
+func (v *NullableFloat64) Set(val *float64) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableFloat64) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableFloat64) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableFloat64(val *float64) *NullableFloat64 {
+	return &NullableFloat64{value: val, isSet: true}
+}
+
+func (v NullableFloat64) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableFloat64) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableString struct {
+	value *string
+	isSet bool
+}
+
+func (v NullableString) Get() *string {
+	return v.value
+}
+
+func (v *NullableString) Set(val *string) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableString) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableString) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableString(val *string) *NullableString {
+	return &NullableString{value: val, isSet: true}
+}
+
+func (v NullableString) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableString) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type NullableTime struct {
+	value *time.Time
+	isSet bool
+}
+
+func (v NullableTime) Get() *time.Time {
+	return v.value
+}
+
+func (v *NullableTime) Set(val *time.Time) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableTime) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableTime) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableTime(val *time.Time) *NullableTime {
+	return &NullableTime{value: val, isSet: true}
+}
+
+func (v NullableTime) MarshalJSON() ([]byte, error) {
+	return v.value.MarshalJSON()
+}
+
+func (v *NullableTime) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+// IsNil checks if an input is nil
+func IsNil(i interface{}) bool {
+	if i == nil {
+		return true
+	}
+	if t, ok := i.(interface{ IsSet() bool }); ok {
+		return !t.IsSet()
+	}
+	switch reflect.TypeOf(i).Kind() {
+	case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.UnsafePointer, reflect.Interface, reflect.Slice:
+		return reflect.ValueOf(i).IsNil()
+	case reflect.Array:
+		return reflect.ValueOf(i).IsZero()
+	}
+	return false
+}
+
+type MappedNullable interface {
+	ToMap() (map[string]interface{}, error)
+}
+
+const letterRunes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+// randString returns a random string with a specified length. It panics if n <= 0.
+func randString(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letterRunes[rand.Intn(len(letterRunes))]
+	}
+	return string(b)
+}