feat: generating code

pkg/runcommandbeta/.openapi-generator/VERSION

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

pkg/runcommandbeta/api_default.go

@@ -0,0 +1,982 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+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 {
+	/*
+		CreateCommand Method for CreateCommand
+		Creates a new command for execution
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param region region
+		@return ApiCreateCommandRequest
+	*/
+	CreateCommand(ctx context.Context, projectId string, serverId string, region string) ApiCreateCommandRequest
+	/*
+		CreateCommandExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param region region
+		@return NewCommandResponse
+
+	*/
+	CreateCommandExecute(ctx context.Context, projectId string, serverId string, region string) (*NewCommandResponse, error)
+	/*
+		GetCommand Method for GetCommand
+		Returns details about a command
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param region region
+		@param serverId Server ID of the machine
+		@param commandId ID of the command
+		@return ApiGetCommandRequest
+	*/
+	GetCommand(ctx context.Context, projectId string, region string, serverId string, commandId string) ApiGetCommandRequest
+	/*
+		GetCommandExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param region region
+		@param serverId Server ID of the machine
+		@param commandId ID of the command
+		@return CommandDetails
+
+	*/
+	GetCommandExecute(ctx context.Context, projectId string, region string, serverId string, commandId string) (*CommandDetails, error)
+	/*
+		GetCommandTemplate Method for GetCommandTemplate
+		Returns details about a command template
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param commandTemplateName Name of the template
+		@param region region
+		@return ApiGetCommandTemplateRequest
+	*/
+	GetCommandTemplate(ctx context.Context, projectId string, serverId string, commandTemplateName string, region string) ApiGetCommandTemplateRequest
+	/*
+		GetCommandTemplateExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param commandTemplateName Name of the template
+		@param region region
+		@return CommandTemplateSchema
+
+	*/
+	GetCommandTemplateExecute(ctx context.Context, projectId string, serverId string, commandTemplateName string, region string) (*CommandTemplateSchema, error)
+	/*
+		ListCommandTemplates Method for ListCommandTemplates
+		Returns a list of command templates
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@return ApiListCommandTemplatesRequest
+	*/
+	ListCommandTemplates(ctx context.Context) ApiListCommandTemplatesRequest
+	/*
+		ListCommandTemplatesExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@return CommandTemplateResponse
+
+	*/
+	ListCommandTemplatesExecute(ctx context.Context) (*CommandTemplateResponse, error)
+	/*
+		ListCommands Method for ListCommands
+		Returns a list of commands
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param region region
+		@return ApiListCommandsRequest
+	*/
+	ListCommands(ctx context.Context, projectId string, serverId string, region string) ApiListCommandsRequest
+	/*
+		ListCommandsExecute executes the request
+
+		@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+		@param projectId ID of the project
+		@param serverId Server ID of the machine
+		@param region region
+		@return GetCommandsResponse
+
+	*/
+	ListCommandsExecute(ctx context.Context, projectId string, serverId string, region string) (*GetCommandsResponse, error)
+}
+
+type ApiCreateCommandRequest interface {
+	// Command to post
+	CreateCommandPayload(createCommandPayload CreateCommandPayload) ApiCreateCommandRequest
+	Execute() (*NewCommandResponse, error)
+}
+
+type ApiGetCommandRequest interface {
+	Execute() (*CommandDetails, error)
+}
+
+type ApiGetCommandTemplateRequest interface {
+	Execute() (*CommandTemplateSchema, error)
+}
+
+type ApiListCommandTemplatesRequest interface {
+	// The type of the Operating System (windows or linux). If not provided will return data for all OS types.
+	OsType(osType string) ApiListCommandTemplatesRequest
+	Execute() (*CommandTemplateResponse, error)
+}
+
+type ApiListCommandsRequest interface {
+	Execute() (*GetCommandsResponse, error)
+}
+
+// DefaultApiService DefaultApi service
+type DefaultApiService service
+
+type CreateCommandRequest struct {
+	ctx                  context.Context
+	apiService           *DefaultApiService
+	projectId            string
+	serverId             string
+	region               string
+	createCommandPayload *CreateCommandPayload
+}
+
+// Command to post
+
+func (r CreateCommandRequest) CreateCommandPayload(createCommandPayload CreateCommandPayload) ApiCreateCommandRequest {
+	r.createCommandPayload = &createCommandPayload
+	return r
+}
+
+func (r CreateCommandRequest) Execute() (*NewCommandResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodPost
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *NewCommandResponse
+	)
+	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.CreateCommand")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(r.serverId, "serverId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	// 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.createCommandPayload
+	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 == 400 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v ErrorResponse
+			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
+}
+
+/*
+CreateCommand: Method for CreateCommand
+
+Creates a new command for execution
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId ID of the project
+	@param serverId Server ID of the machine
+	@param region region
+	@return ApiCreateCommandRequest
+*/
+func (a *APIClient) CreateCommand(ctx context.Context, projectId string, serverId string, region string) ApiCreateCommandRequest {
+	return CreateCommandRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		serverId:   serverId,
+		region:     region,
+	}
+}
+
+func (a *APIClient) CreateCommandExecute(ctx context.Context, projectId string, serverId string, region string) (*NewCommandResponse, error) {
+	r := CreateCommandRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		serverId:   serverId,
+		region:     region,
+	}
+	return r.Execute()
+}
+
+type GetCommandRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	projectId  string
+	region     string
+	serverId   string
+	commandId  string
+}
+
+func (r GetCommandRequest) Execute() (*CommandDetails, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CommandDetails
+	)
+	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.GetCommand")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands/{commandId}"
+	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, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(r.serverId, "serverId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"commandId"+"}", url.PathEscape(ParameterValueToString(r.commandId, "commandId")), -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 == 400 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v ErrorResponse
+			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
+}
+
+/*
+GetCommand: Method for GetCommand
+
+Returns details about a command
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId ID of the project
+	@param region region
+	@param serverId Server ID of the machine
+	@param commandId ID of the command
+	@return ApiGetCommandRequest
+*/
+func (a *APIClient) GetCommand(ctx context.Context, projectId string, region string, serverId string, commandId string) ApiGetCommandRequest {
+	return GetCommandRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		serverId:   serverId,
+		commandId:  commandId,
+	}
+}
+
+func (a *APIClient) GetCommandExecute(ctx context.Context, projectId string, region string, serverId string, commandId string) (*CommandDetails, error) {
+	r := GetCommandRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		region:     region,
+		serverId:   serverId,
+		commandId:  commandId,
+	}
+	return r.Execute()
+}
+
+type GetCommandTemplateRequest struct {
+	ctx                 context.Context
+	apiService          *DefaultApiService
+	projectId           string
+	serverId            string
+	commandTemplateName string
+	region              string
+}
+
+func (r GetCommandTemplateRequest) Execute() (*CommandTemplateSchema, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CommandTemplateSchema
+	)
+	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.GetCommandTemplate")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/command-templates/{commandTemplateName}"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(r.serverId, "serverId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"commandTemplateName"+"}", url.PathEscape(ParameterValueToString(r.commandTemplateName, "commandTemplateName")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -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 == 400 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v ErrorResponse
+			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
+}
+
+/*
+GetCommandTemplate: Method for GetCommandTemplate
+
+Returns details about a command template
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId ID of the project
+	@param serverId Server ID of the machine
+	@param commandTemplateName Name of the template
+	@param region region
+	@return ApiGetCommandTemplateRequest
+*/
+func (a *APIClient) GetCommandTemplate(ctx context.Context, projectId string, serverId string, commandTemplateName string, region string) ApiGetCommandTemplateRequest {
+	return GetCommandTemplateRequest{
+		apiService:          a.defaultApi,
+		ctx:                 ctx,
+		projectId:           projectId,
+		serverId:            serverId,
+		commandTemplateName: commandTemplateName,
+		region:              region,
+	}
+}
+
+func (a *APIClient) GetCommandTemplateExecute(ctx context.Context, projectId string, serverId string, commandTemplateName string, region string) (*CommandTemplateSchema, error) {
+	r := GetCommandTemplateRequest{
+		apiService:          a.defaultApi,
+		ctx:                 ctx,
+		projectId:           projectId,
+		serverId:            serverId,
+		commandTemplateName: commandTemplateName,
+		region:              region,
+	}
+	return r.Execute()
+}
+
+type ListCommandTemplatesRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	osType     *string
+}
+
+// The type of the Operating System (windows or linux). If not provided will return data for all OS types.
+
+func (r ListCommandTemplatesRequest) OsType(osType string) ApiListCommandTemplatesRequest {
+	r.osType = &osType
+	return r
+}
+
+func (r ListCommandTemplatesRequest) Execute() (*CommandTemplateResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CommandTemplateResponse
+	)
+	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.ListCommandTemplates")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/command-templates"
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	if r.osType != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "osType", r.osType, "")
+	}
+	// 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 == 400 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v ErrorResponse
+			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
+}
+
+/*
+ListCommandTemplates: Method for ListCommandTemplates
+
+Returns a list of command templates
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@return ApiListCommandTemplatesRequest
+*/
+func (a *APIClient) ListCommandTemplates(ctx context.Context) ApiListCommandTemplatesRequest {
+	return ListCommandTemplatesRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+	}
+}
+
+func (a *APIClient) ListCommandTemplatesExecute(ctx context.Context) (*CommandTemplateResponse, error) {
+	r := ListCommandTemplatesRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+	}
+	return r.Execute()
+}
+
+type ListCommandsRequest struct {
+	ctx        context.Context
+	apiService *DefaultApiService
+	projectId  string
+	serverId   string
+	region     string
+}
+
+func (r ListCommandsRequest) Execute() (*GetCommandsResponse, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *GetCommandsResponse
+	)
+	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.ListCommands")
+	if err != nil {
+		return localVarReturnValue, &oapierror.GenericOpenAPIError{ErrorMessage: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands"
+	localVarPath = strings.Replace(localVarPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(r.projectId, "projectId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(r.serverId, "serverId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"region"+"}", url.PathEscape(ParameterValueToString(r.region, "region")), -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 == 400 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v ErrorResponse
+			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
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v ErrorResponse
+			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
+}
+
+/*
+ListCommands: Method for ListCommands
+
+Returns a list of commands
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param projectId ID of the project
+	@param serverId Server ID of the machine
+	@param region region
+	@return ApiListCommandsRequest
+*/
+func (a *APIClient) ListCommands(ctx context.Context, projectId string, serverId string, region string) ApiListCommandsRequest {
+	return ListCommandsRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		serverId:   serverId,
+		region:     region,
+	}
+}
+
+func (a *APIClient) ListCommandsExecute(ctx context.Context, projectId string, serverId string, region string) (*GetCommandsResponse, error) {
+	r := ListCommandsRequest{
+		apiService: a.defaultApi,
+		ctx:        ctx,
+		projectId:  projectId,
+		serverId:   serverId,
+		region:     region,
+	}
+	return r.Execute()
+}

pkg/runcommandbeta/api_default_test.go

@@ -0,0 +1,312 @@
+/*
+STACKIT Run Commands Service API
+
+Testing DefaultApiService
+
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech);
+
+package runcommandbeta
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+)
+
+func Test_runcommandbeta_DefaultApiService(t *testing.T) {
+
+	t.Run("Test DefaultApiService CreateCommand", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		serverIdValue := "serverId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(serverIdValue, "serverId")), -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 := NewCommandResponse{}
+			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 runcommandbeta_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
+		serverId := serverIdValue
+		region := regionValue
+
+		resp, reqErr := apiClient.CreateCommand(context.Background(), projectId, serverId, region).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService GetCommand", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands/{commandId}"
+		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)
+		serverIdValue := "serverId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(serverIdValue, "serverId")), -1)
+		commandIdValue := "commandId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"commandId"+"}", url.PathEscape(ParameterValueToString(commandIdValue, "commandId")), -1)
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := CommandDetails{}
+			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 runcommandbeta_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
+		serverId := serverIdValue
+		commandId := commandIdValue
+
+		resp, reqErr := apiClient.GetCommand(context.Background(), projectId, region, serverId, commandId).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService GetCommandTemplate", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/command-templates/{commandTemplateName}"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		serverIdValue := "serverId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(serverIdValue, "serverId")), -1)
+		commandTemplateNameValue := "commandTemplateName-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"commandTemplateName"+"}", url.PathEscape(ParameterValueToString(commandTemplateNameValue, "commandTemplateName")), -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 := CommandTemplateSchema{}
+			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 runcommandbeta_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
+		serverId := serverIdValue
+		commandTemplateName := commandTemplateNameValue
+		region := regionValue
+
+		resp, reqErr := apiClient.GetCommandTemplate(context.Background(), projectId, serverId, commandTemplateName, region).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService ListCommandTemplates", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/command-templates"
+
+		testDefaultApiServeMux := http.NewServeMux()
+		testDefaultApiServeMux.HandleFunc(_apiUrlPath, func(w http.ResponseWriter, req *http.Request) {
+			data := CommandTemplateResponse{}
+			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 runcommandbeta_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)
+		}
+
+		resp, reqErr := apiClient.ListCommandTemplates(context.Background()).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+	t.Run("Test DefaultApiService ListCommands", func(t *testing.T) {
+		_apiUrlPath := "/v2beta/projects/{projectId}/regions/{region}/servers/{serverId}/commands"
+		projectIdValue := "projectId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"projectId"+"}", url.PathEscape(ParameterValueToString(projectIdValue, "projectId")), -1)
+		serverIdValue := "serverId-value"
+		_apiUrlPath = strings.Replace(_apiUrlPath, "{"+"serverId"+"}", url.PathEscape(ParameterValueToString(serverIdValue, "serverId")), -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 := GetCommandsResponse{}
+			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 runcommandbeta_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
+		serverId := serverIdValue
+		region := regionValue
+
+		resp, reqErr := apiClient.ListCommands(context.Background(), projectId, serverId, region).Execute()
+
+		if reqErr != nil {
+			t.Fatalf("error in call: %v", reqErr)
+		}
+		if IsNil(resp) {
+			t.Fatalf("response not present")
+		}
+	})
+
+}

pkg/runcommandbeta/client.go

@@ -0,0 +1,631 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+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 Run Commands Service API API v2beta.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
+	}
+	err = file.Close()
+	if err != nil {
+		return err
+	}
+
+	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/runcommandbeta/configuration.go

@@ -0,0 +1,38 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+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/runcommandbeta",
+		Debug:         false,
+		Servers: config.ServerConfigurations{
+			{
+				URL:         "https://run-command.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/runcommandbeta/model_command_details.go

@@ -0,0 +1,620 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// checks if the CommandDetails type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CommandDetails{}
+
+/*
+	types and functions for commandTemplateName
+*/
+
+// isNotNullableString
+type CommandDetailsGetCommandTemplateNameAttributeType = *string
+
+func getCommandDetailsGetCommandTemplateNameAttributeTypeOk(arg CommandDetailsGetCommandTemplateNameAttributeType) (ret CommandDetailsGetCommandTemplateNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetCommandTemplateNameAttributeType(arg *CommandDetailsGetCommandTemplateNameAttributeType, val CommandDetailsGetCommandTemplateNameRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetCommandTemplateNameArgType = string
+type CommandDetailsGetCommandTemplateNameRetType = string
+
+/*
+	types and functions for commandTemplateTitle
+*/
+
+// isNotNullableString
+type CommandDetailsGetCommandTemplateTitleAttributeType = *string
+
+func getCommandDetailsGetCommandTemplateTitleAttributeTypeOk(arg CommandDetailsGetCommandTemplateTitleAttributeType) (ret CommandDetailsGetCommandTemplateTitleRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetCommandTemplateTitleAttributeType(arg *CommandDetailsGetCommandTemplateTitleAttributeType, val CommandDetailsGetCommandTemplateTitleRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetCommandTemplateTitleArgType = string
+type CommandDetailsGetCommandTemplateTitleRetType = string
+
+/*
+	types and functions for exitCode
+*/
+
+// isInteger
+type CommandDetailsGetExitCodeAttributeType = *int64
+type CommandDetailsGetExitCodeArgType = int64
+type CommandDetailsGetExitCodeRetType = int64
+
+func getCommandDetailsGetExitCodeAttributeTypeOk(arg CommandDetailsGetExitCodeAttributeType) (ret CommandDetailsGetExitCodeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetExitCodeAttributeType(arg *CommandDetailsGetExitCodeAttributeType, val CommandDetailsGetExitCodeRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for finishedAt
+*/
+
+// isNotNullableString
+type CommandDetailsGetFinishedAtAttributeType = *string
+
+func getCommandDetailsGetFinishedAtAttributeTypeOk(arg CommandDetailsGetFinishedAtAttributeType) (ret CommandDetailsGetFinishedAtRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetFinishedAtAttributeType(arg *CommandDetailsGetFinishedAtAttributeType, val CommandDetailsGetFinishedAtRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetFinishedAtArgType = string
+type CommandDetailsGetFinishedAtRetType = string
+
+/*
+	types and functions for id
+*/
+
+// isInteger
+type CommandDetailsGetIdAttributeType = *int64
+type CommandDetailsGetIdArgType = int64
+type CommandDetailsGetIdRetType = int64
+
+func getCommandDetailsGetIdAttributeTypeOk(arg CommandDetailsGetIdAttributeType) (ret CommandDetailsGetIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetIdAttributeType(arg *CommandDetailsGetIdAttributeType, val CommandDetailsGetIdRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for output
+*/
+
+// isNotNullableString
+type CommandDetailsGetOutputAttributeType = *string
+
+func getCommandDetailsGetOutputAttributeTypeOk(arg CommandDetailsGetOutputAttributeType) (ret CommandDetailsGetOutputRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetOutputAttributeType(arg *CommandDetailsGetOutputAttributeType, val CommandDetailsGetOutputRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetOutputArgType = string
+type CommandDetailsGetOutputRetType = string
+
+/*
+	types and functions for script
+*/
+
+// isNotNullableString
+type CommandDetailsGetScriptAttributeType = *string
+
+func getCommandDetailsGetScriptAttributeTypeOk(arg CommandDetailsGetScriptAttributeType) (ret CommandDetailsGetScriptRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetScriptAttributeType(arg *CommandDetailsGetScriptAttributeType, val CommandDetailsGetScriptRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetScriptArgType = string
+type CommandDetailsGetScriptRetType = string
+
+/*
+	types and functions for startedAt
+*/
+
+// isNotNullableString
+type CommandDetailsGetStartedAtAttributeType = *string
+
+func getCommandDetailsGetStartedAtAttributeTypeOk(arg CommandDetailsGetStartedAtAttributeType) (ret CommandDetailsGetStartedAtRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetStartedAtAttributeType(arg *CommandDetailsGetStartedAtAttributeType, val CommandDetailsGetStartedAtRetType) {
+	*arg = &val
+}
+
+type CommandDetailsGetStartedAtArgType = string
+type CommandDetailsGetStartedAtRetType = string
+
+/*
+	types and functions for status
+*/
+
+// isEnum
+
+// CommandDetailsStatus the model 'CommandDetails'
+// value type for enums
+type CommandDetailsStatus string
+
+// List of Status
+const (
+	COMMANDDETAILSSTATUS_PENDING   CommandDetailsStatus = "pending"
+	COMMANDDETAILSSTATUS_RUNNING   CommandDetailsStatus = "running"
+	COMMANDDETAILSSTATUS_COMPLETED CommandDetailsStatus = "completed"
+	COMMANDDETAILSSTATUS_FAILED    CommandDetailsStatus = "failed"
+)
+
+// All allowed values of CommandDetails enum
+var AllowedCommandDetailsStatusEnumValues = []CommandDetailsStatus{
+	"pending",
+	"running",
+	"completed",
+	"failed",
+}
+
+func (v *CommandDetailsStatus) UnmarshalJSON(src []byte) error {
+	// use a type alias to prevent infinite recursion during unmarshal,
+	// see https://biscuit.ninja/posts/go-avoid-an-infitine-loop-with-custom-json-unmarshallers
+	type TmpJson CommandDetailsStatus
+	var value TmpJson
+	err := json.Unmarshal(src, &value)
+	if err != nil {
+		return err
+	}
+	// Allow unmarshalling zero value for testing purposes
+	var zeroValue TmpJson
+	if value == zeroValue {
+		return nil
+	}
+	enumTypeValue := CommandDetailsStatus(value)
+	for _, existing := range AllowedCommandDetailsStatusEnumValues {
+		if existing == enumTypeValue {
+			*v = enumTypeValue
+			return nil
+		}
+	}
+
+	return fmt.Errorf("%+v is not a valid CommandDetails", value)
+}
+
+// NewCommandDetailsStatusFromValue returns a pointer to a valid CommandDetailsStatus
+// for the value passed as argument, or an error if the value passed is not allowed by the enum
+func NewCommandDetailsStatusFromValue(v CommandDetailsStatus) (*CommandDetailsStatus, error) {
+	ev := CommandDetailsStatus(v)
+	if ev.IsValid() {
+		return &ev, nil
+	} else {
+		return nil, fmt.Errorf("invalid value '%v' for CommandDetailsStatus: valid values are %v", v, AllowedCommandDetailsStatusEnumValues)
+	}
+}
+
+// IsValid return true if the value is valid for the enum, false otherwise
+func (v CommandDetailsStatus) IsValid() bool {
+	for _, existing := range AllowedCommandDetailsStatusEnumValues {
+		if existing == v {
+			return true
+		}
+	}
+	return false
+}
+
+// Ptr returns reference to StatusStatus value
+func (v CommandDetailsStatus) Ptr() *CommandDetailsStatus {
+	return &v
+}
+
+type NullableCommandDetailsStatus struct {
+	value *CommandDetailsStatus
+	isSet bool
+}
+
+func (v NullableCommandDetailsStatus) Get() *CommandDetailsStatus {
+	return v.value
+}
+
+func (v *NullableCommandDetailsStatus) Set(val *CommandDetailsStatus) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandDetailsStatus) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandDetailsStatus) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandDetailsStatus(val *CommandDetailsStatus) *NullableCommandDetailsStatus {
+	return &NullableCommandDetailsStatus{value: val, isSet: true}
+}
+
+func (v NullableCommandDetailsStatus) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandDetailsStatus) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type CommandDetailsGetStatusAttributeType = *CommandDetailsStatus
+type CommandDetailsGetStatusArgType = CommandDetailsStatus
+type CommandDetailsGetStatusRetType = CommandDetailsStatus
+
+func getCommandDetailsGetStatusAttributeTypeOk(arg CommandDetailsGetStatusAttributeType) (ret CommandDetailsGetStatusRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandDetailsGetStatusAttributeType(arg *CommandDetailsGetStatusAttributeType, val CommandDetailsGetStatusRetType) {
+	*arg = &val
+}
+
+// CommandDetails struct for CommandDetails
+type CommandDetails struct {
+	CommandTemplateName  CommandDetailsGetCommandTemplateNameAttributeType  `json:"commandTemplateName,omitempty"`
+	CommandTemplateTitle CommandDetailsGetCommandTemplateTitleAttributeType `json:"commandTemplateTitle,omitempty"`
+	// Can be cast to int32 without loss of precision.
+	ExitCode   CommandDetailsGetExitCodeAttributeType   `json:"exitCode,omitempty"`
+	FinishedAt CommandDetailsGetFinishedAtAttributeType `json:"finishedAt,omitempty"`
+	// Can be cast to int32 without loss of precision.
+	Id        CommandDetailsGetIdAttributeType        `json:"id,omitempty"`
+	Output    CommandDetailsGetOutputAttributeType    `json:"output,omitempty"`
+	Script    CommandDetailsGetScriptAttributeType    `json:"script,omitempty"`
+	StartedAt CommandDetailsGetStartedAtAttributeType `json:"startedAt,omitempty"`
+	Status    CommandDetailsGetStatusAttributeType    `json:"status,omitempty"`
+}
+
+// NewCommandDetails instantiates a new CommandDetails 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 NewCommandDetails() *CommandDetails {
+	this := CommandDetails{}
+	return &this
+}
+
+// NewCommandDetailsWithDefaults instantiates a new CommandDetails 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 NewCommandDetailsWithDefaults() *CommandDetails {
+	this := CommandDetails{}
+	return &this
+}
+
+// GetCommandTemplateName returns the CommandTemplateName field value if set, zero value otherwise.
+func (o *CommandDetails) GetCommandTemplateName() (res CommandDetailsGetCommandTemplateNameRetType) {
+	res, _ = o.GetCommandTemplateNameOk()
+	return
+}
+
+// GetCommandTemplateNameOk returns a tuple with the CommandTemplateName field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetCommandTemplateNameOk() (ret CommandDetailsGetCommandTemplateNameRetType, ok bool) {
+	return getCommandDetailsGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName)
+}
+
+// HasCommandTemplateName returns a boolean if a field has been set.
+func (o *CommandDetails) HasCommandTemplateName() bool {
+	_, ok := o.GetCommandTemplateNameOk()
+	return ok
+}
+
+// SetCommandTemplateName gets a reference to the given string and assigns it to the CommandTemplateName field.
+func (o *CommandDetails) SetCommandTemplateName(v CommandDetailsGetCommandTemplateNameRetType) {
+	setCommandDetailsGetCommandTemplateNameAttributeType(&o.CommandTemplateName, v)
+}
+
+// GetCommandTemplateTitle returns the CommandTemplateTitle field value if set, zero value otherwise.
+func (o *CommandDetails) GetCommandTemplateTitle() (res CommandDetailsGetCommandTemplateTitleRetType) {
+	res, _ = o.GetCommandTemplateTitleOk()
+	return
+}
+
+// GetCommandTemplateTitleOk returns a tuple with the CommandTemplateTitle field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetCommandTemplateTitleOk() (ret CommandDetailsGetCommandTemplateTitleRetType, ok bool) {
+	return getCommandDetailsGetCommandTemplateTitleAttributeTypeOk(o.CommandTemplateTitle)
+}
+
+// HasCommandTemplateTitle returns a boolean if a field has been set.
+func (o *CommandDetails) HasCommandTemplateTitle() bool {
+	_, ok := o.GetCommandTemplateTitleOk()
+	return ok
+}
+
+// SetCommandTemplateTitle gets a reference to the given string and assigns it to the CommandTemplateTitle field.
+func (o *CommandDetails) SetCommandTemplateTitle(v CommandDetailsGetCommandTemplateTitleRetType) {
+	setCommandDetailsGetCommandTemplateTitleAttributeType(&o.CommandTemplateTitle, v)
+}
+
+// GetExitCode returns the ExitCode field value if set, zero value otherwise.
+func (o *CommandDetails) GetExitCode() (res CommandDetailsGetExitCodeRetType) {
+	res, _ = o.GetExitCodeOk()
+	return
+}
+
+// GetExitCodeOk returns a tuple with the ExitCode field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetExitCodeOk() (ret CommandDetailsGetExitCodeRetType, ok bool) {
+	return getCommandDetailsGetExitCodeAttributeTypeOk(o.ExitCode)
+}
+
+// HasExitCode returns a boolean if a field has been set.
+func (o *CommandDetails) HasExitCode() bool {
+	_, ok := o.GetExitCodeOk()
+	return ok
+}
+
+// SetExitCode gets a reference to the given int64 and assigns it to the ExitCode field.
+func (o *CommandDetails) SetExitCode(v CommandDetailsGetExitCodeRetType) {
+	setCommandDetailsGetExitCodeAttributeType(&o.ExitCode, v)
+}
+
+// GetFinishedAt returns the FinishedAt field value if set, zero value otherwise.
+func (o *CommandDetails) GetFinishedAt() (res CommandDetailsGetFinishedAtRetType) {
+	res, _ = o.GetFinishedAtOk()
+	return
+}
+
+// GetFinishedAtOk returns a tuple with the FinishedAt field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetFinishedAtOk() (ret CommandDetailsGetFinishedAtRetType, ok bool) {
+	return getCommandDetailsGetFinishedAtAttributeTypeOk(o.FinishedAt)
+}
+
+// HasFinishedAt returns a boolean if a field has been set.
+func (o *CommandDetails) HasFinishedAt() bool {
+	_, ok := o.GetFinishedAtOk()
+	return ok
+}
+
+// SetFinishedAt gets a reference to the given string and assigns it to the FinishedAt field.
+func (o *CommandDetails) SetFinishedAt(v CommandDetailsGetFinishedAtRetType) {
+	setCommandDetailsGetFinishedAtAttributeType(&o.FinishedAt, v)
+}
+
+// GetId returns the Id field value if set, zero value otherwise.
+func (o *CommandDetails) GetId() (res CommandDetailsGetIdRetType) {
+	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 *CommandDetails) GetIdOk() (ret CommandDetailsGetIdRetType, ok bool) {
+	return getCommandDetailsGetIdAttributeTypeOk(o.Id)
+}
+
+// HasId returns a boolean if a field has been set.
+func (o *CommandDetails) HasId() bool {
+	_, ok := o.GetIdOk()
+	return ok
+}
+
+// SetId gets a reference to the given int64 and assigns it to the Id field.
+func (o *CommandDetails) SetId(v CommandDetailsGetIdRetType) {
+	setCommandDetailsGetIdAttributeType(&o.Id, v)
+}
+
+// GetOutput returns the Output field value if set, zero value otherwise.
+func (o *CommandDetails) GetOutput() (res CommandDetailsGetOutputRetType) {
+	res, _ = o.GetOutputOk()
+	return
+}
+
+// GetOutputOk returns a tuple with the Output field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetOutputOk() (ret CommandDetailsGetOutputRetType, ok bool) {
+	return getCommandDetailsGetOutputAttributeTypeOk(o.Output)
+}
+
+// HasOutput returns a boolean if a field has been set.
+func (o *CommandDetails) HasOutput() bool {
+	_, ok := o.GetOutputOk()
+	return ok
+}
+
+// SetOutput gets a reference to the given string and assigns it to the Output field.
+func (o *CommandDetails) SetOutput(v CommandDetailsGetOutputRetType) {
+	setCommandDetailsGetOutputAttributeType(&o.Output, v)
+}
+
+// GetScript returns the Script field value if set, zero value otherwise.
+func (o *CommandDetails) GetScript() (res CommandDetailsGetScriptRetType) {
+	res, _ = o.GetScriptOk()
+	return
+}
+
+// GetScriptOk returns a tuple with the Script field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetScriptOk() (ret CommandDetailsGetScriptRetType, ok bool) {
+	return getCommandDetailsGetScriptAttributeTypeOk(o.Script)
+}
+
+// HasScript returns a boolean if a field has been set.
+func (o *CommandDetails) HasScript() bool {
+	_, ok := o.GetScriptOk()
+	return ok
+}
+
+// SetScript gets a reference to the given string and assigns it to the Script field.
+func (o *CommandDetails) SetScript(v CommandDetailsGetScriptRetType) {
+	setCommandDetailsGetScriptAttributeType(&o.Script, v)
+}
+
+// GetStartedAt returns the StartedAt field value if set, zero value otherwise.
+func (o *CommandDetails) GetStartedAt() (res CommandDetailsGetStartedAtRetType) {
+	res, _ = o.GetStartedAtOk()
+	return
+}
+
+// GetStartedAtOk returns a tuple with the StartedAt field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetStartedAtOk() (ret CommandDetailsGetStartedAtRetType, ok bool) {
+	return getCommandDetailsGetStartedAtAttributeTypeOk(o.StartedAt)
+}
+
+// HasStartedAt returns a boolean if a field has been set.
+func (o *CommandDetails) HasStartedAt() bool {
+	_, ok := o.GetStartedAtOk()
+	return ok
+}
+
+// SetStartedAt gets a reference to the given string and assigns it to the StartedAt field.
+func (o *CommandDetails) SetStartedAt(v CommandDetailsGetStartedAtRetType) {
+	setCommandDetailsGetStartedAtAttributeType(&o.StartedAt, v)
+}
+
+// GetStatus returns the Status field value if set, zero value otherwise.
+func (o *CommandDetails) GetStatus() (res CommandDetailsGetStatusRetType) {
+	res, _ = o.GetStatusOk()
+	return
+}
+
+// GetStatusOk returns a tuple with the Status field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandDetails) GetStatusOk() (ret CommandDetailsGetStatusRetType, ok bool) {
+	return getCommandDetailsGetStatusAttributeTypeOk(o.Status)
+}
+
+// HasStatus returns a boolean if a field has been set.
+func (o *CommandDetails) HasStatus() bool {
+	_, ok := o.GetStatusOk()
+	return ok
+}
+
+// SetStatus gets a reference to the given string and assigns it to the Status field.
+func (o *CommandDetails) SetStatus(v CommandDetailsGetStatusRetType) {
+	setCommandDetailsGetStatusAttributeType(&o.Status, v)
+}
+
+func (o CommandDetails) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCommandDetailsGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName); ok {
+		toSerialize["CommandTemplateName"] = val
+	}
+	if val, ok := getCommandDetailsGetCommandTemplateTitleAttributeTypeOk(o.CommandTemplateTitle); ok {
+		toSerialize["CommandTemplateTitle"] = val
+	}
+	if val, ok := getCommandDetailsGetExitCodeAttributeTypeOk(o.ExitCode); ok {
+		toSerialize["ExitCode"] = val
+	}
+	if val, ok := getCommandDetailsGetFinishedAtAttributeTypeOk(o.FinishedAt); ok {
+		toSerialize["FinishedAt"] = val
+	}
+	if val, ok := getCommandDetailsGetIdAttributeTypeOk(o.Id); ok {
+		toSerialize["Id"] = val
+	}
+	if val, ok := getCommandDetailsGetOutputAttributeTypeOk(o.Output); ok {
+		toSerialize["Output"] = val
+	}
+	if val, ok := getCommandDetailsGetScriptAttributeTypeOk(o.Script); ok {
+		toSerialize["Script"] = val
+	}
+	if val, ok := getCommandDetailsGetStartedAtAttributeTypeOk(o.StartedAt); ok {
+		toSerialize["StartedAt"] = val
+	}
+	if val, ok := getCommandDetailsGetStatusAttributeTypeOk(o.Status); ok {
+		toSerialize["Status"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCommandDetails struct {
+	value *CommandDetails
+	isSet bool
+}
+
+func (v NullableCommandDetails) Get() *CommandDetails {
+	return v.value
+}
+
+func (v *NullableCommandDetails) Set(val *CommandDetails) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandDetails) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandDetails) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandDetails(val *CommandDetails) *NullableCommandDetails {
+	return &NullableCommandDetails{value: val, isSet: true}
+}
+
+func (v NullableCommandDetails) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandDetails) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_command_details_test.go

@@ -0,0 +1,72 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"testing"
+)
+
+// isEnum
+
+func TestCommandDetailsStatus_UnmarshalJSON(t *testing.T) {
+	type args struct {
+		src []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: `success - possible enum value no. 1`,
+			args: args{
+				src: []byte(`"pending"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 2`,
+			args: args{
+				src: []byte(`"running"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 3`,
+			args: args{
+				src: []byte(`"completed"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 4`,
+			args: args{
+				src: []byte(`"failed"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: "fail",
+			args: args{
+				src: []byte("\"FOOBAR\""),
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := CommandDetailsStatus("")
+			if err := v.UnmarshalJSON(tt.args.src); (err != nil) != tt.wantErr {
+				t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

pkg/runcommandbeta/model_command_template.go

@@ -0,0 +1,223 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CommandTemplate type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CommandTemplate{}
+
+/*
+	types and functions for name
+*/
+
+// isNotNullableString
+type CommandTemplateGetNameAttributeType = *string
+
+func getCommandTemplateGetNameAttributeTypeOk(arg CommandTemplateGetNameAttributeType) (ret CommandTemplateGetNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateGetNameAttributeType(arg *CommandTemplateGetNameAttributeType, val CommandTemplateGetNameRetType) {
+	*arg = &val
+}
+
+type CommandTemplateGetNameArgType = string
+type CommandTemplateGetNameRetType = string
+
+/*
+	types and functions for osType
+*/
+
+// isArray
+type CommandTemplateGetOsTypeAttributeType = *[]string
+type CommandTemplateGetOsTypeArgType = []string
+type CommandTemplateGetOsTypeRetType = []string
+
+func getCommandTemplateGetOsTypeAttributeTypeOk(arg CommandTemplateGetOsTypeAttributeType) (ret CommandTemplateGetOsTypeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateGetOsTypeAttributeType(arg *CommandTemplateGetOsTypeAttributeType, val CommandTemplateGetOsTypeRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for title
+*/
+
+// isNotNullableString
+type CommandTemplateGetTitleAttributeType = *string
+
+func getCommandTemplateGetTitleAttributeTypeOk(arg CommandTemplateGetTitleAttributeType) (ret CommandTemplateGetTitleRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateGetTitleAttributeType(arg *CommandTemplateGetTitleAttributeType, val CommandTemplateGetTitleRetType) {
+	*arg = &val
+}
+
+type CommandTemplateGetTitleArgType = string
+type CommandTemplateGetTitleRetType = string
+
+// CommandTemplate struct for CommandTemplate
+type CommandTemplate struct {
+	Name   CommandTemplateGetNameAttributeType   `json:"name,omitempty"`
+	OsType CommandTemplateGetOsTypeAttributeType `json:"osType,omitempty"`
+	Title  CommandTemplateGetTitleAttributeType  `json:"title,omitempty"`
+}
+
+// NewCommandTemplate instantiates a new CommandTemplate 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 NewCommandTemplate() *CommandTemplate {
+	this := CommandTemplate{}
+	return &this
+}
+
+// NewCommandTemplateWithDefaults instantiates a new CommandTemplate 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 NewCommandTemplateWithDefaults() *CommandTemplate {
+	this := CommandTemplate{}
+	return &this
+}
+
+// GetName returns the Name field value if set, zero value otherwise.
+func (o *CommandTemplate) GetName() (res CommandTemplateGetNameRetType) {
+	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 *CommandTemplate) GetNameOk() (ret CommandTemplateGetNameRetType, ok bool) {
+	return getCommandTemplateGetNameAttributeTypeOk(o.Name)
+}
+
+// HasName returns a boolean if a field has been set.
+func (o *CommandTemplate) HasName() bool {
+	_, ok := o.GetNameOk()
+	return ok
+}
+
+// SetName gets a reference to the given string and assigns it to the Name field.
+func (o *CommandTemplate) SetName(v CommandTemplateGetNameRetType) {
+	setCommandTemplateGetNameAttributeType(&o.Name, v)
+}
+
+// GetOsType returns the OsType field value if set, zero value otherwise.
+func (o *CommandTemplate) GetOsType() (res CommandTemplateGetOsTypeRetType) {
+	res, _ = o.GetOsTypeOk()
+	return
+}
+
+// GetOsTypeOk returns a tuple with the OsType field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplate) GetOsTypeOk() (ret CommandTemplateGetOsTypeRetType, ok bool) {
+	return getCommandTemplateGetOsTypeAttributeTypeOk(o.OsType)
+}
+
+// HasOsType returns a boolean if a field has been set.
+func (o *CommandTemplate) HasOsType() bool {
+	_, ok := o.GetOsTypeOk()
+	return ok
+}
+
+// SetOsType gets a reference to the given []string and assigns it to the OsType field.
+func (o *CommandTemplate) SetOsType(v CommandTemplateGetOsTypeRetType) {
+	setCommandTemplateGetOsTypeAttributeType(&o.OsType, v)
+}
+
+// GetTitle returns the Title field value if set, zero value otherwise.
+func (o *CommandTemplate) GetTitle() (res CommandTemplateGetTitleRetType) {
+	res, _ = o.GetTitleOk()
+	return
+}
+
+// GetTitleOk returns a tuple with the Title field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplate) GetTitleOk() (ret CommandTemplateGetTitleRetType, ok bool) {
+	return getCommandTemplateGetTitleAttributeTypeOk(o.Title)
+}
+
+// HasTitle returns a boolean if a field has been set.
+func (o *CommandTemplate) HasTitle() bool {
+	_, ok := o.GetTitleOk()
+	return ok
+}
+
+// SetTitle gets a reference to the given string and assigns it to the Title field.
+func (o *CommandTemplate) SetTitle(v CommandTemplateGetTitleRetType) {
+	setCommandTemplateGetTitleAttributeType(&o.Title, v)
+}
+
+func (o CommandTemplate) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCommandTemplateGetNameAttributeTypeOk(o.Name); ok {
+		toSerialize["Name"] = val
+	}
+	if val, ok := getCommandTemplateGetOsTypeAttributeTypeOk(o.OsType); ok {
+		toSerialize["OsType"] = val
+	}
+	if val, ok := getCommandTemplateGetTitleAttributeTypeOk(o.Title); ok {
+		toSerialize["Title"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCommandTemplate struct {
+	value *CommandTemplate
+	isSet bool
+}
+
+func (v NullableCommandTemplate) Get() *CommandTemplate {
+	return v.value
+}
+
+func (v *NullableCommandTemplate) Set(val *CommandTemplate) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandTemplate) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandTemplate) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandTemplate(val *CommandTemplate) *NullableCommandTemplate {
+	return &NullableCommandTemplate{value: val, isSet: true}
+}
+
+func (v NullableCommandTemplate) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandTemplate) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_command_template_response.go

@@ -0,0 +1,127 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CommandTemplateResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CommandTemplateResponse{}
+
+/*
+	types and functions for items
+*/
+
+// isArray
+type CommandTemplateResponseGetItemsAttributeType = *[]CommandTemplate
+type CommandTemplateResponseGetItemsArgType = []CommandTemplate
+type CommandTemplateResponseGetItemsRetType = []CommandTemplate
+
+func getCommandTemplateResponseGetItemsAttributeTypeOk(arg CommandTemplateResponseGetItemsAttributeType) (ret CommandTemplateResponseGetItemsRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateResponseGetItemsAttributeType(arg *CommandTemplateResponseGetItemsAttributeType, val CommandTemplateResponseGetItemsRetType) {
+	*arg = &val
+}
+
+// CommandTemplateResponse struct for CommandTemplateResponse
+type CommandTemplateResponse struct {
+	Items CommandTemplateResponseGetItemsAttributeType `json:"items,omitempty"`
+}
+
+// NewCommandTemplateResponse instantiates a new CommandTemplateResponse 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 NewCommandTemplateResponse() *CommandTemplateResponse {
+	this := CommandTemplateResponse{}
+	return &this
+}
+
+// NewCommandTemplateResponseWithDefaults instantiates a new CommandTemplateResponse 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 NewCommandTemplateResponseWithDefaults() *CommandTemplateResponse {
+	this := CommandTemplateResponse{}
+	return &this
+}
+
+// GetItems returns the Items field value if set, zero value otherwise.
+func (o *CommandTemplateResponse) GetItems() (res CommandTemplateResponseGetItemsRetType) {
+	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 *CommandTemplateResponse) GetItemsOk() (ret CommandTemplateResponseGetItemsRetType, ok bool) {
+	return getCommandTemplateResponseGetItemsAttributeTypeOk(o.Items)
+}
+
+// HasItems returns a boolean if a field has been set.
+func (o *CommandTemplateResponse) HasItems() bool {
+	_, ok := o.GetItemsOk()
+	return ok
+}
+
+// SetItems gets a reference to the given []CommandTemplate and assigns it to the Items field.
+func (o *CommandTemplateResponse) SetItems(v CommandTemplateResponseGetItemsRetType) {
+	setCommandTemplateResponseGetItemsAttributeType(&o.Items, v)
+}
+
+func (o CommandTemplateResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCommandTemplateResponseGetItemsAttributeTypeOk(o.Items); ok {
+		toSerialize["Items"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCommandTemplateResponse struct {
+	value *CommandTemplateResponse
+	isSet bool
+}
+
+func (v NullableCommandTemplateResponse) Get() *CommandTemplateResponse {
+	return v.value
+}
+
+func (v *NullableCommandTemplateResponse) Set(val *CommandTemplateResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandTemplateResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandTemplateResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandTemplateResponse(val *CommandTemplateResponse) *NullableCommandTemplateResponse {
+	return &NullableCommandTemplateResponse{value: val, isSet: true}
+}
+
+func (v NullableCommandTemplateResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandTemplateResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_command_template_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_command_template_schema.go

@@ -0,0 +1,318 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CommandTemplateSchema type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CommandTemplateSchema{}
+
+/*
+	types and functions for description
+*/
+
+// isNotNullableString
+type CommandTemplateSchemaGetDescriptionAttributeType = *string
+
+func getCommandTemplateSchemaGetDescriptionAttributeTypeOk(arg CommandTemplateSchemaGetDescriptionAttributeType) (ret CommandTemplateSchemaGetDescriptionRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateSchemaGetDescriptionAttributeType(arg *CommandTemplateSchemaGetDescriptionAttributeType, val CommandTemplateSchemaGetDescriptionRetType) {
+	*arg = &val
+}
+
+type CommandTemplateSchemaGetDescriptionArgType = string
+type CommandTemplateSchemaGetDescriptionRetType = string
+
+/*
+	types and functions for name
+*/
+
+// isNotNullableString
+type CommandTemplateSchemaGetNameAttributeType = *string
+
+func getCommandTemplateSchemaGetNameAttributeTypeOk(arg CommandTemplateSchemaGetNameAttributeType) (ret CommandTemplateSchemaGetNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateSchemaGetNameAttributeType(arg *CommandTemplateSchemaGetNameAttributeType, val CommandTemplateSchemaGetNameRetType) {
+	*arg = &val
+}
+
+type CommandTemplateSchemaGetNameArgType = string
+type CommandTemplateSchemaGetNameRetType = string
+
+/*
+	types and functions for osType
+*/
+
+// isArray
+type CommandTemplateSchemaGetOsTypeAttributeType = *[]string
+type CommandTemplateSchemaGetOsTypeArgType = []string
+type CommandTemplateSchemaGetOsTypeRetType = []string
+
+func getCommandTemplateSchemaGetOsTypeAttributeTypeOk(arg CommandTemplateSchemaGetOsTypeAttributeType) (ret CommandTemplateSchemaGetOsTypeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateSchemaGetOsTypeAttributeType(arg *CommandTemplateSchemaGetOsTypeAttributeType, val CommandTemplateSchemaGetOsTypeRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for parameterSchema
+*/
+
+// isModel
+type CommandTemplateSchemaGetParameterSchemaAttributeType = *ParametersSchema
+type CommandTemplateSchemaGetParameterSchemaArgType = ParametersSchema
+type CommandTemplateSchemaGetParameterSchemaRetType = ParametersSchema
+
+func getCommandTemplateSchemaGetParameterSchemaAttributeTypeOk(arg CommandTemplateSchemaGetParameterSchemaAttributeType) (ret CommandTemplateSchemaGetParameterSchemaRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateSchemaGetParameterSchemaAttributeType(arg *CommandTemplateSchemaGetParameterSchemaAttributeType, val CommandTemplateSchemaGetParameterSchemaRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for title
+*/
+
+// isNotNullableString
+type CommandTemplateSchemaGetTitleAttributeType = *string
+
+func getCommandTemplateSchemaGetTitleAttributeTypeOk(arg CommandTemplateSchemaGetTitleAttributeType) (ret CommandTemplateSchemaGetTitleRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandTemplateSchemaGetTitleAttributeType(arg *CommandTemplateSchemaGetTitleAttributeType, val CommandTemplateSchemaGetTitleRetType) {
+	*arg = &val
+}
+
+type CommandTemplateSchemaGetTitleArgType = string
+type CommandTemplateSchemaGetTitleRetType = string
+
+// CommandTemplateSchema struct for CommandTemplateSchema
+type CommandTemplateSchema struct {
+	Description     CommandTemplateSchemaGetDescriptionAttributeType     `json:"description,omitempty"`
+	Name            CommandTemplateSchemaGetNameAttributeType            `json:"name,omitempty"`
+	OsType          CommandTemplateSchemaGetOsTypeAttributeType          `json:"osType,omitempty"`
+	ParameterSchema CommandTemplateSchemaGetParameterSchemaAttributeType `json:"parameterSchema,omitempty"`
+	Title           CommandTemplateSchemaGetTitleAttributeType           `json:"title,omitempty"`
+}
+
+// NewCommandTemplateSchema instantiates a new CommandTemplateSchema 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 NewCommandTemplateSchema() *CommandTemplateSchema {
+	this := CommandTemplateSchema{}
+	return &this
+}
+
+// NewCommandTemplateSchemaWithDefaults instantiates a new CommandTemplateSchema 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 NewCommandTemplateSchemaWithDefaults() *CommandTemplateSchema {
+	this := CommandTemplateSchema{}
+	return &this
+}
+
+// GetDescription returns the Description field value if set, zero value otherwise.
+func (o *CommandTemplateSchema) GetDescription() (res CommandTemplateSchemaGetDescriptionRetType) {
+	res, _ = o.GetDescriptionOk()
+	return
+}
+
+// GetDescriptionOk returns a tuple with the Description field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplateSchema) GetDescriptionOk() (ret CommandTemplateSchemaGetDescriptionRetType, ok bool) {
+	return getCommandTemplateSchemaGetDescriptionAttributeTypeOk(o.Description)
+}
+
+// HasDescription returns a boolean if a field has been set.
+func (o *CommandTemplateSchema) HasDescription() bool {
+	_, ok := o.GetDescriptionOk()
+	return ok
+}
+
+// SetDescription gets a reference to the given string and assigns it to the Description field.
+func (o *CommandTemplateSchema) SetDescription(v CommandTemplateSchemaGetDescriptionRetType) {
+	setCommandTemplateSchemaGetDescriptionAttributeType(&o.Description, v)
+}
+
+// GetName returns the Name field value if set, zero value otherwise.
+func (o *CommandTemplateSchema) GetName() (res CommandTemplateSchemaGetNameRetType) {
+	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 *CommandTemplateSchema) GetNameOk() (ret CommandTemplateSchemaGetNameRetType, ok bool) {
+	return getCommandTemplateSchemaGetNameAttributeTypeOk(o.Name)
+}
+
+// HasName returns a boolean if a field has been set.
+func (o *CommandTemplateSchema) HasName() bool {
+	_, ok := o.GetNameOk()
+	return ok
+}
+
+// SetName gets a reference to the given string and assigns it to the Name field.
+func (o *CommandTemplateSchema) SetName(v CommandTemplateSchemaGetNameRetType) {
+	setCommandTemplateSchemaGetNameAttributeType(&o.Name, v)
+}
+
+// GetOsType returns the OsType field value if set, zero value otherwise.
+func (o *CommandTemplateSchema) GetOsType() (res CommandTemplateSchemaGetOsTypeRetType) {
+	res, _ = o.GetOsTypeOk()
+	return
+}
+
+// GetOsTypeOk returns a tuple with the OsType field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplateSchema) GetOsTypeOk() (ret CommandTemplateSchemaGetOsTypeRetType, ok bool) {
+	return getCommandTemplateSchemaGetOsTypeAttributeTypeOk(o.OsType)
+}
+
+// HasOsType returns a boolean if a field has been set.
+func (o *CommandTemplateSchema) HasOsType() bool {
+	_, ok := o.GetOsTypeOk()
+	return ok
+}
+
+// SetOsType gets a reference to the given []string and assigns it to the OsType field.
+func (o *CommandTemplateSchema) SetOsType(v CommandTemplateSchemaGetOsTypeRetType) {
+	setCommandTemplateSchemaGetOsTypeAttributeType(&o.OsType, v)
+}
+
+// GetParameterSchema returns the ParameterSchema field value if set, zero value otherwise.
+func (o *CommandTemplateSchema) GetParameterSchema() (res CommandTemplateSchemaGetParameterSchemaRetType) {
+	res, _ = o.GetParameterSchemaOk()
+	return
+}
+
+// GetParameterSchemaOk returns a tuple with the ParameterSchema field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplateSchema) GetParameterSchemaOk() (ret CommandTemplateSchemaGetParameterSchemaRetType, ok bool) {
+	return getCommandTemplateSchemaGetParameterSchemaAttributeTypeOk(o.ParameterSchema)
+}
+
+// HasParameterSchema returns a boolean if a field has been set.
+func (o *CommandTemplateSchema) HasParameterSchema() bool {
+	_, ok := o.GetParameterSchemaOk()
+	return ok
+}
+
+// SetParameterSchema gets a reference to the given ParametersSchema and assigns it to the ParameterSchema field.
+func (o *CommandTemplateSchema) SetParameterSchema(v CommandTemplateSchemaGetParameterSchemaRetType) {
+	setCommandTemplateSchemaGetParameterSchemaAttributeType(&o.ParameterSchema, v)
+}
+
+// GetTitle returns the Title field value if set, zero value otherwise.
+func (o *CommandTemplateSchema) GetTitle() (res CommandTemplateSchemaGetTitleRetType) {
+	res, _ = o.GetTitleOk()
+	return
+}
+
+// GetTitleOk returns a tuple with the Title field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CommandTemplateSchema) GetTitleOk() (ret CommandTemplateSchemaGetTitleRetType, ok bool) {
+	return getCommandTemplateSchemaGetTitleAttributeTypeOk(o.Title)
+}
+
+// HasTitle returns a boolean if a field has been set.
+func (o *CommandTemplateSchema) HasTitle() bool {
+	_, ok := o.GetTitleOk()
+	return ok
+}
+
+// SetTitle gets a reference to the given string and assigns it to the Title field.
+func (o *CommandTemplateSchema) SetTitle(v CommandTemplateSchemaGetTitleRetType) {
+	setCommandTemplateSchemaGetTitleAttributeType(&o.Title, v)
+}
+
+func (o CommandTemplateSchema) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCommandTemplateSchemaGetDescriptionAttributeTypeOk(o.Description); ok {
+		toSerialize["Description"] = val
+	}
+	if val, ok := getCommandTemplateSchemaGetNameAttributeTypeOk(o.Name); ok {
+		toSerialize["Name"] = val
+	}
+	if val, ok := getCommandTemplateSchemaGetOsTypeAttributeTypeOk(o.OsType); ok {
+		toSerialize["OsType"] = val
+	}
+	if val, ok := getCommandTemplateSchemaGetParameterSchemaAttributeTypeOk(o.ParameterSchema); ok {
+		toSerialize["ParameterSchema"] = val
+	}
+	if val, ok := getCommandTemplateSchemaGetTitleAttributeTypeOk(o.Title); ok {
+		toSerialize["Title"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCommandTemplateSchema struct {
+	value *CommandTemplateSchema
+	isSet bool
+}
+
+func (v NullableCommandTemplateSchema) Get() *CommandTemplateSchema {
+	return v.value
+}
+
+func (v *NullableCommandTemplateSchema) Set(val *CommandTemplateSchema) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandTemplateSchema) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandTemplateSchema) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandTemplateSchema(val *CommandTemplateSchema) *NullableCommandTemplateSchema {
+	return &NullableCommandTemplateSchema{value: val, isSet: true}
+}
+
+func (v NullableCommandTemplateSchema) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandTemplateSchema) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_command_template_schema_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_command_template_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_commands.go

@@ -0,0 +1,476 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// checks if the Commands type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &Commands{}
+
+/*
+	types and functions for commandTemplateName
+*/
+
+// isNotNullableString
+type CommandsGetCommandTemplateNameAttributeType = *string
+
+func getCommandsGetCommandTemplateNameAttributeTypeOk(arg CommandsGetCommandTemplateNameAttributeType) (ret CommandsGetCommandTemplateNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetCommandTemplateNameAttributeType(arg *CommandsGetCommandTemplateNameAttributeType, val CommandsGetCommandTemplateNameRetType) {
+	*arg = &val
+}
+
+type CommandsGetCommandTemplateNameArgType = string
+type CommandsGetCommandTemplateNameRetType = string
+
+/*
+	types and functions for commandTemplateTitle
+*/
+
+// isNotNullableString
+type CommandsGetCommandTemplateTitleAttributeType = *string
+
+func getCommandsGetCommandTemplateTitleAttributeTypeOk(arg CommandsGetCommandTemplateTitleAttributeType) (ret CommandsGetCommandTemplateTitleRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetCommandTemplateTitleAttributeType(arg *CommandsGetCommandTemplateTitleAttributeType, val CommandsGetCommandTemplateTitleRetType) {
+	*arg = &val
+}
+
+type CommandsGetCommandTemplateTitleArgType = string
+type CommandsGetCommandTemplateTitleRetType = string
+
+/*
+	types and functions for finishedAt
+*/
+
+// isNotNullableString
+type CommandsGetFinishedAtAttributeType = *string
+
+func getCommandsGetFinishedAtAttributeTypeOk(arg CommandsGetFinishedAtAttributeType) (ret CommandsGetFinishedAtRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetFinishedAtAttributeType(arg *CommandsGetFinishedAtAttributeType, val CommandsGetFinishedAtRetType) {
+	*arg = &val
+}
+
+type CommandsGetFinishedAtArgType = string
+type CommandsGetFinishedAtRetType = string
+
+/*
+	types and functions for id
+*/
+
+// isInteger
+type CommandsGetIdAttributeType = *int64
+type CommandsGetIdArgType = int64
+type CommandsGetIdRetType = int64
+
+func getCommandsGetIdAttributeTypeOk(arg CommandsGetIdAttributeType) (ret CommandsGetIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetIdAttributeType(arg *CommandsGetIdAttributeType, val CommandsGetIdRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for startedAt
+*/
+
+// isNotNullableString
+type CommandsGetStartedAtAttributeType = *string
+
+func getCommandsGetStartedAtAttributeTypeOk(arg CommandsGetStartedAtAttributeType) (ret CommandsGetStartedAtRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetStartedAtAttributeType(arg *CommandsGetStartedAtAttributeType, val CommandsGetStartedAtRetType) {
+	*arg = &val
+}
+
+type CommandsGetStartedAtArgType = string
+type CommandsGetStartedAtRetType = string
+
+/*
+	types and functions for status
+*/
+
+// isEnum
+
+// CommandsStatus the model 'Commands'
+// value type for enums
+type CommandsStatus string
+
+// List of Status
+const (
+	COMMANDSSTATUS_PENDING   CommandsStatus = "pending"
+	COMMANDSSTATUS_RUNNING   CommandsStatus = "running"
+	COMMANDSSTATUS_COMPLETED CommandsStatus = "completed"
+	COMMANDSSTATUS_FAILED    CommandsStatus = "failed"
+)
+
+// All allowed values of Commands enum
+var AllowedCommandsStatusEnumValues = []CommandsStatus{
+	"pending",
+	"running",
+	"completed",
+	"failed",
+}
+
+func (v *CommandsStatus) UnmarshalJSON(src []byte) error {
+	// use a type alias to prevent infinite recursion during unmarshal,
+	// see https://biscuit.ninja/posts/go-avoid-an-infitine-loop-with-custom-json-unmarshallers
+	type TmpJson CommandsStatus
+	var value TmpJson
+	err := json.Unmarshal(src, &value)
+	if err != nil {
+		return err
+	}
+	// Allow unmarshalling zero value for testing purposes
+	var zeroValue TmpJson
+	if value == zeroValue {
+		return nil
+	}
+	enumTypeValue := CommandsStatus(value)
+	for _, existing := range AllowedCommandsStatusEnumValues {
+		if existing == enumTypeValue {
+			*v = enumTypeValue
+			return nil
+		}
+	}
+
+	return fmt.Errorf("%+v is not a valid Commands", value)
+}
+
+// NewCommandsStatusFromValue returns a pointer to a valid CommandsStatus
+// for the value passed as argument, or an error if the value passed is not allowed by the enum
+func NewCommandsStatusFromValue(v CommandsStatus) (*CommandsStatus, error) {
+	ev := CommandsStatus(v)
+	if ev.IsValid() {
+		return &ev, nil
+	} else {
+		return nil, fmt.Errorf("invalid value '%v' for CommandsStatus: valid values are %v", v, AllowedCommandsStatusEnumValues)
+	}
+}
+
+// IsValid return true if the value is valid for the enum, false otherwise
+func (v CommandsStatus) IsValid() bool {
+	for _, existing := range AllowedCommandsStatusEnumValues {
+		if existing == v {
+			return true
+		}
+	}
+	return false
+}
+
+// Ptr returns reference to StatusStatus value
+func (v CommandsStatus) Ptr() *CommandsStatus {
+	return &v
+}
+
+type NullableCommandsStatus struct {
+	value *CommandsStatus
+	isSet bool
+}
+
+func (v NullableCommandsStatus) Get() *CommandsStatus {
+	return v.value
+}
+
+func (v *NullableCommandsStatus) Set(val *CommandsStatus) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommandsStatus) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommandsStatus) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommandsStatus(val *CommandsStatus) *NullableCommandsStatus {
+	return &NullableCommandsStatus{value: val, isSet: true}
+}
+
+func (v NullableCommandsStatus) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommandsStatus) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}
+
+type CommandsGetStatusAttributeType = *CommandsStatus
+type CommandsGetStatusArgType = CommandsStatus
+type CommandsGetStatusRetType = CommandsStatus
+
+func getCommandsGetStatusAttributeTypeOk(arg CommandsGetStatusAttributeType) (ret CommandsGetStatusRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCommandsGetStatusAttributeType(arg *CommandsGetStatusAttributeType, val CommandsGetStatusRetType) {
+	*arg = &val
+}
+
+// Commands struct for Commands
+type Commands struct {
+	CommandTemplateName  CommandsGetCommandTemplateNameAttributeType  `json:"commandTemplateName,omitempty"`
+	CommandTemplateTitle CommandsGetCommandTemplateTitleAttributeType `json:"commandTemplateTitle,omitempty"`
+	FinishedAt           CommandsGetFinishedAtAttributeType           `json:"finishedAt,omitempty"`
+	// Can be cast to int32 without loss of precision.
+	Id        CommandsGetIdAttributeType        `json:"id,omitempty"`
+	StartedAt CommandsGetStartedAtAttributeType `json:"startedAt,omitempty"`
+	Status    CommandsGetStatusAttributeType    `json:"status,omitempty"`
+}
+
+// NewCommands instantiates a new Commands 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 NewCommands() *Commands {
+	this := Commands{}
+	return &this
+}
+
+// NewCommandsWithDefaults instantiates a new Commands 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 NewCommandsWithDefaults() *Commands {
+	this := Commands{}
+	return &this
+}
+
+// GetCommandTemplateName returns the CommandTemplateName field value if set, zero value otherwise.
+func (o *Commands) GetCommandTemplateName() (res CommandsGetCommandTemplateNameRetType) {
+	res, _ = o.GetCommandTemplateNameOk()
+	return
+}
+
+// GetCommandTemplateNameOk returns a tuple with the CommandTemplateName field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Commands) GetCommandTemplateNameOk() (ret CommandsGetCommandTemplateNameRetType, ok bool) {
+	return getCommandsGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName)
+}
+
+// HasCommandTemplateName returns a boolean if a field has been set.
+func (o *Commands) HasCommandTemplateName() bool {
+	_, ok := o.GetCommandTemplateNameOk()
+	return ok
+}
+
+// SetCommandTemplateName gets a reference to the given string and assigns it to the CommandTemplateName field.
+func (o *Commands) SetCommandTemplateName(v CommandsGetCommandTemplateNameRetType) {
+	setCommandsGetCommandTemplateNameAttributeType(&o.CommandTemplateName, v)
+}
+
+// GetCommandTemplateTitle returns the CommandTemplateTitle field value if set, zero value otherwise.
+func (o *Commands) GetCommandTemplateTitle() (res CommandsGetCommandTemplateTitleRetType) {
+	res, _ = o.GetCommandTemplateTitleOk()
+	return
+}
+
+// GetCommandTemplateTitleOk returns a tuple with the CommandTemplateTitle field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Commands) GetCommandTemplateTitleOk() (ret CommandsGetCommandTemplateTitleRetType, ok bool) {
+	return getCommandsGetCommandTemplateTitleAttributeTypeOk(o.CommandTemplateTitle)
+}
+
+// HasCommandTemplateTitle returns a boolean if a field has been set.
+func (o *Commands) HasCommandTemplateTitle() bool {
+	_, ok := o.GetCommandTemplateTitleOk()
+	return ok
+}
+
+// SetCommandTemplateTitle gets a reference to the given string and assigns it to the CommandTemplateTitle field.
+func (o *Commands) SetCommandTemplateTitle(v CommandsGetCommandTemplateTitleRetType) {
+	setCommandsGetCommandTemplateTitleAttributeType(&o.CommandTemplateTitle, v)
+}
+
+// GetFinishedAt returns the FinishedAt field value if set, zero value otherwise.
+func (o *Commands) GetFinishedAt() (res CommandsGetFinishedAtRetType) {
+	res, _ = o.GetFinishedAtOk()
+	return
+}
+
+// GetFinishedAtOk returns a tuple with the FinishedAt field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Commands) GetFinishedAtOk() (ret CommandsGetFinishedAtRetType, ok bool) {
+	return getCommandsGetFinishedAtAttributeTypeOk(o.FinishedAt)
+}
+
+// HasFinishedAt returns a boolean if a field has been set.
+func (o *Commands) HasFinishedAt() bool {
+	_, ok := o.GetFinishedAtOk()
+	return ok
+}
+
+// SetFinishedAt gets a reference to the given string and assigns it to the FinishedAt field.
+func (o *Commands) SetFinishedAt(v CommandsGetFinishedAtRetType) {
+	setCommandsGetFinishedAtAttributeType(&o.FinishedAt, v)
+}
+
+// GetId returns the Id field value if set, zero value otherwise.
+func (o *Commands) GetId() (res CommandsGetIdRetType) {
+	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 *Commands) GetIdOk() (ret CommandsGetIdRetType, ok bool) {
+	return getCommandsGetIdAttributeTypeOk(o.Id)
+}
+
+// HasId returns a boolean if a field has been set.
+func (o *Commands) HasId() bool {
+	_, ok := o.GetIdOk()
+	return ok
+}
+
+// SetId gets a reference to the given int64 and assigns it to the Id field.
+func (o *Commands) SetId(v CommandsGetIdRetType) {
+	setCommandsGetIdAttributeType(&o.Id, v)
+}
+
+// GetStartedAt returns the StartedAt field value if set, zero value otherwise.
+func (o *Commands) GetStartedAt() (res CommandsGetStartedAtRetType) {
+	res, _ = o.GetStartedAtOk()
+	return
+}
+
+// GetStartedAtOk returns a tuple with the StartedAt field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Commands) GetStartedAtOk() (ret CommandsGetStartedAtRetType, ok bool) {
+	return getCommandsGetStartedAtAttributeTypeOk(o.StartedAt)
+}
+
+// HasStartedAt returns a boolean if a field has been set.
+func (o *Commands) HasStartedAt() bool {
+	_, ok := o.GetStartedAtOk()
+	return ok
+}
+
+// SetStartedAt gets a reference to the given string and assigns it to the StartedAt field.
+func (o *Commands) SetStartedAt(v CommandsGetStartedAtRetType) {
+	setCommandsGetStartedAtAttributeType(&o.StartedAt, v)
+}
+
+// GetStatus returns the Status field value if set, zero value otherwise.
+func (o *Commands) GetStatus() (res CommandsGetStatusRetType) {
+	res, _ = o.GetStatusOk()
+	return
+}
+
+// GetStatusOk returns a tuple with the Status field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Commands) GetStatusOk() (ret CommandsGetStatusRetType, ok bool) {
+	return getCommandsGetStatusAttributeTypeOk(o.Status)
+}
+
+// HasStatus returns a boolean if a field has been set.
+func (o *Commands) HasStatus() bool {
+	_, ok := o.GetStatusOk()
+	return ok
+}
+
+// SetStatus gets a reference to the given string and assigns it to the Status field.
+func (o *Commands) SetStatus(v CommandsGetStatusRetType) {
+	setCommandsGetStatusAttributeType(&o.Status, v)
+}
+
+func (o Commands) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCommandsGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName); ok {
+		toSerialize["CommandTemplateName"] = val
+	}
+	if val, ok := getCommandsGetCommandTemplateTitleAttributeTypeOk(o.CommandTemplateTitle); ok {
+		toSerialize["CommandTemplateTitle"] = val
+	}
+	if val, ok := getCommandsGetFinishedAtAttributeTypeOk(o.FinishedAt); ok {
+		toSerialize["FinishedAt"] = val
+	}
+	if val, ok := getCommandsGetIdAttributeTypeOk(o.Id); ok {
+		toSerialize["Id"] = val
+	}
+	if val, ok := getCommandsGetStartedAtAttributeTypeOk(o.StartedAt); ok {
+		toSerialize["StartedAt"] = val
+	}
+	if val, ok := getCommandsGetStatusAttributeTypeOk(o.Status); ok {
+		toSerialize["Status"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCommands struct {
+	value *Commands
+	isSet bool
+}
+
+func (v NullableCommands) Get() *Commands {
+	return v.value
+}
+
+func (v *NullableCommands) Set(val *Commands) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCommands) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCommands) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCommands(val *Commands) *NullableCommands {
+	return &NullableCommands{value: val, isSet: true}
+}
+
+func (v NullableCommands) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCommands) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_commands_test.go

@@ -0,0 +1,72 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"testing"
+)
+
+// isEnum
+
+func TestCommandsStatus_UnmarshalJSON(t *testing.T) {
+	type args struct {
+		src []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: `success - possible enum value no. 1`,
+			args: args{
+				src: []byte(`"pending"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 2`,
+			args: args{
+				src: []byte(`"running"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 3`,
+			args: args{
+				src: []byte(`"completed"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: `success - possible enum value no. 4`,
+			args: args{
+				src: []byte(`"failed"`),
+			},
+			wantErr: false,
+		},
+		{
+			name: "fail",
+			args: args{
+				src: []byte("\"FOOBAR\""),
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := CommandsStatus("")
+			if err := v.UnmarshalJSON(tt.args.src); (err != nil) != tt.wantErr {
+				t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

pkg/runcommandbeta/model_create_command_payload.go

@@ -0,0 +1,173 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the CreateCommandPayload type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CreateCommandPayload{}
+
+/*
+	types and functions for commandTemplateName
+*/
+
+// isNotNullableString
+type CreateCommandPayloadGetCommandTemplateNameAttributeType = *string
+
+func getCreateCommandPayloadGetCommandTemplateNameAttributeTypeOk(arg CreateCommandPayloadGetCommandTemplateNameAttributeType) (ret CreateCommandPayloadGetCommandTemplateNameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCommandPayloadGetCommandTemplateNameAttributeType(arg *CreateCommandPayloadGetCommandTemplateNameAttributeType, val CreateCommandPayloadGetCommandTemplateNameRetType) {
+	*arg = &val
+}
+
+type CreateCommandPayloadGetCommandTemplateNameArgType = string
+type CreateCommandPayloadGetCommandTemplateNameRetType = string
+
+/*
+	types and functions for parameters
+*/
+
+// isContainer
+type CreateCommandPayloadGetParametersAttributeType = *map[string]string
+type CreateCommandPayloadGetParametersArgType = map[string]string
+type CreateCommandPayloadGetParametersRetType = map[string]string
+
+func getCreateCommandPayloadGetParametersAttributeTypeOk(arg CreateCommandPayloadGetParametersAttributeType) (ret CreateCommandPayloadGetParametersRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setCreateCommandPayloadGetParametersAttributeType(arg *CreateCommandPayloadGetParametersAttributeType, val CreateCommandPayloadGetParametersRetType) {
+	*arg = &val
+}
+
+// CreateCommandPayload struct for CreateCommandPayload
+type CreateCommandPayload struct {
+	// REQUIRED
+	CommandTemplateName CreateCommandPayloadGetCommandTemplateNameAttributeType `json:"commandTemplateName" required:"true"`
+	Parameters          CreateCommandPayloadGetParametersAttributeType          `json:"parameters,omitempty"`
+}
+
+type _CreateCommandPayload CreateCommandPayload
+
+// NewCreateCommandPayload instantiates a new CreateCommandPayload 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 NewCreateCommandPayload(commandTemplateName CreateCommandPayloadGetCommandTemplateNameArgType) *CreateCommandPayload {
+	this := CreateCommandPayload{}
+	setCreateCommandPayloadGetCommandTemplateNameAttributeType(&this.CommandTemplateName, commandTemplateName)
+	return &this
+}
+
+// NewCreateCommandPayloadWithDefaults instantiates a new CreateCommandPayload 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 NewCreateCommandPayloadWithDefaults() *CreateCommandPayload {
+	this := CreateCommandPayload{}
+	return &this
+}
+
+// GetCommandTemplateName returns the CommandTemplateName field value
+func (o *CreateCommandPayload) GetCommandTemplateName() (ret CreateCommandPayloadGetCommandTemplateNameRetType) {
+	ret, _ = o.GetCommandTemplateNameOk()
+	return ret
+}
+
+// GetCommandTemplateNameOk returns a tuple with the CommandTemplateName field value
+// and a boolean to check if the value has been set.
+func (o *CreateCommandPayload) GetCommandTemplateNameOk() (ret CreateCommandPayloadGetCommandTemplateNameRetType, ok bool) {
+	return getCreateCommandPayloadGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName)
+}
+
+// SetCommandTemplateName sets field value
+func (o *CreateCommandPayload) SetCommandTemplateName(v CreateCommandPayloadGetCommandTemplateNameRetType) {
+	setCreateCommandPayloadGetCommandTemplateNameAttributeType(&o.CommandTemplateName, v)
+}
+
+// GetParameters returns the Parameters field value if set, zero value otherwise.
+func (o *CreateCommandPayload) GetParameters() (res CreateCommandPayloadGetParametersRetType) {
+	res, _ = o.GetParametersOk()
+	return
+}
+
+// GetParametersOk returns a tuple with the Parameters field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CreateCommandPayload) GetParametersOk() (ret CreateCommandPayloadGetParametersRetType, ok bool) {
+	return getCreateCommandPayloadGetParametersAttributeTypeOk(o.Parameters)
+}
+
+// HasParameters returns a boolean if a field has been set.
+func (o *CreateCommandPayload) HasParameters() bool {
+	_, ok := o.GetParametersOk()
+	return ok
+}
+
+// SetParameters gets a reference to the given map[string]string and assigns it to the Parameters field.
+func (o *CreateCommandPayload) SetParameters(v CreateCommandPayloadGetParametersRetType) {
+	setCreateCommandPayloadGetParametersAttributeType(&o.Parameters, v)
+}
+
+func (o CreateCommandPayload) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getCreateCommandPayloadGetCommandTemplateNameAttributeTypeOk(o.CommandTemplateName); ok {
+		toSerialize["CommandTemplateName"] = val
+	}
+	if val, ok := getCreateCommandPayloadGetParametersAttributeTypeOk(o.Parameters); ok {
+		toSerialize["Parameters"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableCreateCommandPayload struct {
+	value *CreateCommandPayload
+	isSet bool
+}
+
+func (v NullableCreateCommandPayload) Get() *CreateCommandPayload {
+	return v.value
+}
+
+func (v *NullableCreateCommandPayload) Set(val *CreateCommandPayload) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCreateCommandPayload) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCreateCommandPayload) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCreateCommandPayload(val *CreateCommandPayload) *NullableCreateCommandPayload {
+	return &NullableCreateCommandPayload{value: val, isSet: true}
+}
+
+func (v NullableCreateCommandPayload) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCreateCommandPayload) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_create_command_payload_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_error_response.go

@@ -0,0 +1,172 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the ErrorResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &ErrorResponse{}
+
+/*
+	types and functions for message
+*/
+
+// isNotNullableString
+type ErrorResponseGetMessageAttributeType = *string
+
+func getErrorResponseGetMessageAttributeTypeOk(arg ErrorResponseGetMessageAttributeType) (ret ErrorResponseGetMessageRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setErrorResponseGetMessageAttributeType(arg *ErrorResponseGetMessageAttributeType, val ErrorResponseGetMessageRetType) {
+	*arg = &val
+}
+
+type ErrorResponseGetMessageArgType = string
+type ErrorResponseGetMessageRetType = string
+
+/*
+	types and functions for status
+*/
+
+// isNotNullableString
+type ErrorResponseGetStatusAttributeType = *string
+
+func getErrorResponseGetStatusAttributeTypeOk(arg ErrorResponseGetStatusAttributeType) (ret ErrorResponseGetStatusRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setErrorResponseGetStatusAttributeType(arg *ErrorResponseGetStatusAttributeType, val ErrorResponseGetStatusRetType) {
+	*arg = &val
+}
+
+type ErrorResponseGetStatusArgType = string
+type ErrorResponseGetStatusRetType = string
+
+// ErrorResponse struct for ErrorResponse
+type ErrorResponse struct {
+	// Details about the error
+	// REQUIRED
+	Message ErrorResponseGetMessageAttributeType `json:"message" required:"true"`
+	// The string representation of the http status code (i.e. Not Found, Bad Request, etc)
+	// REQUIRED
+	Status ErrorResponseGetStatusAttributeType `json:"status" required:"true"`
+}
+
+type _ErrorResponse ErrorResponse
+
+// NewErrorResponse instantiates a new ErrorResponse 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 NewErrorResponse(message ErrorResponseGetMessageArgType, status ErrorResponseGetStatusArgType) *ErrorResponse {
+	this := ErrorResponse{}
+	setErrorResponseGetMessageAttributeType(&this.Message, message)
+	setErrorResponseGetStatusAttributeType(&this.Status, status)
+	return &this
+}
+
+// NewErrorResponseWithDefaults instantiates a new ErrorResponse 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 NewErrorResponseWithDefaults() *ErrorResponse {
+	this := ErrorResponse{}
+	return &this
+}
+
+// GetMessage returns the Message field value
+func (o *ErrorResponse) GetMessage() (ret ErrorResponseGetMessageRetType) {
+	ret, _ = o.GetMessageOk()
+	return ret
+}
+
+// GetMessageOk returns a tuple with the Message field value
+// and a boolean to check if the value has been set.
+func (o *ErrorResponse) GetMessageOk() (ret ErrorResponseGetMessageRetType, ok bool) {
+	return getErrorResponseGetMessageAttributeTypeOk(o.Message)
+}
+
+// SetMessage sets field value
+func (o *ErrorResponse) SetMessage(v ErrorResponseGetMessageRetType) {
+	setErrorResponseGetMessageAttributeType(&o.Message, v)
+}
+
+// GetStatus returns the Status field value
+func (o *ErrorResponse) GetStatus() (ret ErrorResponseGetStatusRetType) {
+	ret, _ = o.GetStatusOk()
+	return ret
+}
+
+// GetStatusOk returns a tuple with the Status field value
+// and a boolean to check if the value has been set.
+func (o *ErrorResponse) GetStatusOk() (ret ErrorResponseGetStatusRetType, ok bool) {
+	return getErrorResponseGetStatusAttributeTypeOk(o.Status)
+}
+
+// SetStatus sets field value
+func (o *ErrorResponse) SetStatus(v ErrorResponseGetStatusRetType) {
+	setErrorResponseGetStatusAttributeType(&o.Status, v)
+}
+
+func (o ErrorResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getErrorResponseGetMessageAttributeTypeOk(o.Message); ok {
+		toSerialize["Message"] = val
+	}
+	if val, ok := getErrorResponseGetStatusAttributeTypeOk(o.Status); ok {
+		toSerialize["Status"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableErrorResponse struct {
+	value *ErrorResponse
+	isSet bool
+}
+
+func (v NullableErrorResponse) Get() *ErrorResponse {
+	return v.value
+}
+
+func (v *NullableErrorResponse) Set(val *ErrorResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableErrorResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableErrorResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableErrorResponse(val *ErrorResponse) *NullableErrorResponse {
+	return &NullableErrorResponse{value: val, isSet: true}
+}
+
+func (v NullableErrorResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableErrorResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_error_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_field.go

@@ -0,0 +1,415 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the Field type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &Field{}
+
+/*
+	types and functions for default
+*/
+
+// isNotNullableString
+type FieldGetDefaultAttributeType = *string
+
+func getFieldGetDefaultAttributeTypeOk(arg FieldGetDefaultAttributeType) (ret FieldGetDefaultRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetDefaultAttributeType(arg *FieldGetDefaultAttributeType, val FieldGetDefaultRetType) {
+	*arg = &val
+}
+
+type FieldGetDefaultArgType = string
+type FieldGetDefaultRetType = string
+
+/*
+	types and functions for description
+*/
+
+// isNotNullableString
+type FieldGetDescriptionAttributeType = *string
+
+func getFieldGetDescriptionAttributeTypeOk(arg FieldGetDescriptionAttributeType) (ret FieldGetDescriptionRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetDescriptionAttributeType(arg *FieldGetDescriptionAttributeType, val FieldGetDescriptionRetType) {
+	*arg = &val
+}
+
+type FieldGetDescriptionArgType = string
+type FieldGetDescriptionRetType = string
+
+/*
+	types and functions for maxLen
+*/
+
+// isInteger
+type FieldGetMaxLenAttributeType = *int64
+type FieldGetMaxLenArgType = int64
+type FieldGetMaxLenRetType = int64
+
+func getFieldGetMaxLenAttributeTypeOk(arg FieldGetMaxLenAttributeType) (ret FieldGetMaxLenRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetMaxLenAttributeType(arg *FieldGetMaxLenAttributeType, val FieldGetMaxLenRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for minLen
+*/
+
+// isInteger
+type FieldGetMinLenAttributeType = *int64
+type FieldGetMinLenArgType = int64
+type FieldGetMinLenRetType = int64
+
+func getFieldGetMinLenAttributeTypeOk(arg FieldGetMinLenAttributeType) (ret FieldGetMinLenRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetMinLenAttributeType(arg *FieldGetMinLenAttributeType, val FieldGetMinLenRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for readOnly
+*/
+
+// isBoolean
+type FieldgetReadOnlyAttributeType = *bool
+type FieldgetReadOnlyArgType = bool
+type FieldgetReadOnlyRetType = bool
+
+func getFieldgetReadOnlyAttributeTypeOk(arg FieldgetReadOnlyAttributeType) (ret FieldgetReadOnlyRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldgetReadOnlyAttributeType(arg *FieldgetReadOnlyAttributeType, val FieldgetReadOnlyRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for title
+*/
+
+// isNotNullableString
+type FieldGetTitleAttributeType = *string
+
+func getFieldGetTitleAttributeTypeOk(arg FieldGetTitleAttributeType) (ret FieldGetTitleRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetTitleAttributeType(arg *FieldGetTitleAttributeType, val FieldGetTitleRetType) {
+	*arg = &val
+}
+
+type FieldGetTitleArgType = string
+type FieldGetTitleRetType = string
+
+/*
+	types and functions for type
+*/
+
+// isNotNullableString
+type FieldGetTypeAttributeType = *string
+
+func getFieldGetTypeAttributeTypeOk(arg FieldGetTypeAttributeType) (ret FieldGetTypeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setFieldGetTypeAttributeType(arg *FieldGetTypeAttributeType, val FieldGetTypeRetType) {
+	*arg = &val
+}
+
+type FieldGetTypeArgType = string
+type FieldGetTypeRetType = string
+
+// Field struct for Field
+type Field struct {
+	Default     FieldGetDefaultAttributeType     `json:"default,omitempty"`
+	Description FieldGetDescriptionAttributeType `json:"description,omitempty"`
+	// Can be cast to int32 without loss of precision.
+	MaxLen FieldGetMaxLenAttributeType `json:"maxLen,omitempty"`
+	// Can be cast to int32 without loss of precision.
+	MinLen   FieldGetMinLenAttributeType   `json:"minLen,omitempty"`
+	ReadOnly FieldgetReadOnlyAttributeType `json:"readOnly,omitempty"`
+	Title    FieldGetTitleAttributeType    `json:"title,omitempty"`
+	Type     FieldGetTypeAttributeType     `json:"type,omitempty"`
+}
+
+// NewField instantiates a new Field 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 NewField() *Field {
+	this := Field{}
+	return &this
+}
+
+// NewFieldWithDefaults instantiates a new Field 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 NewFieldWithDefaults() *Field {
+	this := Field{}
+	return &this
+}
+
+// GetDefault returns the Default field value if set, zero value otherwise.
+func (o *Field) GetDefault() (res FieldGetDefaultRetType) {
+	res, _ = o.GetDefaultOk()
+	return
+}
+
+// GetDefaultOk returns a tuple with the Default field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetDefaultOk() (ret FieldGetDefaultRetType, ok bool) {
+	return getFieldGetDefaultAttributeTypeOk(o.Default)
+}
+
+// HasDefault returns a boolean if a field has been set.
+func (o *Field) HasDefault() bool {
+	_, ok := o.GetDefaultOk()
+	return ok
+}
+
+// SetDefault gets a reference to the given string and assigns it to the Default field.
+func (o *Field) SetDefault(v FieldGetDefaultRetType) {
+	setFieldGetDefaultAttributeType(&o.Default, v)
+}
+
+// GetDescription returns the Description field value if set, zero value otherwise.
+func (o *Field) GetDescription() (res FieldGetDescriptionRetType) {
+	res, _ = o.GetDescriptionOk()
+	return
+}
+
+// GetDescriptionOk returns a tuple with the Description field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetDescriptionOk() (ret FieldGetDescriptionRetType, ok bool) {
+	return getFieldGetDescriptionAttributeTypeOk(o.Description)
+}
+
+// HasDescription returns a boolean if a field has been set.
+func (o *Field) HasDescription() bool {
+	_, ok := o.GetDescriptionOk()
+	return ok
+}
+
+// SetDescription gets a reference to the given string and assigns it to the Description field.
+func (o *Field) SetDescription(v FieldGetDescriptionRetType) {
+	setFieldGetDescriptionAttributeType(&o.Description, v)
+}
+
+// GetMaxLen returns the MaxLen field value if set, zero value otherwise.
+func (o *Field) GetMaxLen() (res FieldGetMaxLenRetType) {
+	res, _ = o.GetMaxLenOk()
+	return
+}
+
+// GetMaxLenOk returns a tuple with the MaxLen field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetMaxLenOk() (ret FieldGetMaxLenRetType, ok bool) {
+	return getFieldGetMaxLenAttributeTypeOk(o.MaxLen)
+}
+
+// HasMaxLen returns a boolean if a field has been set.
+func (o *Field) HasMaxLen() bool {
+	_, ok := o.GetMaxLenOk()
+	return ok
+}
+
+// SetMaxLen gets a reference to the given int64 and assigns it to the MaxLen field.
+func (o *Field) SetMaxLen(v FieldGetMaxLenRetType) {
+	setFieldGetMaxLenAttributeType(&o.MaxLen, v)
+}
+
+// GetMinLen returns the MinLen field value if set, zero value otherwise.
+func (o *Field) GetMinLen() (res FieldGetMinLenRetType) {
+	res, _ = o.GetMinLenOk()
+	return
+}
+
+// GetMinLenOk returns a tuple with the MinLen field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetMinLenOk() (ret FieldGetMinLenRetType, ok bool) {
+	return getFieldGetMinLenAttributeTypeOk(o.MinLen)
+}
+
+// HasMinLen returns a boolean if a field has been set.
+func (o *Field) HasMinLen() bool {
+	_, ok := o.GetMinLenOk()
+	return ok
+}
+
+// SetMinLen gets a reference to the given int64 and assigns it to the MinLen field.
+func (o *Field) SetMinLen(v FieldGetMinLenRetType) {
+	setFieldGetMinLenAttributeType(&o.MinLen, v)
+}
+
+// GetReadOnly returns the ReadOnly field value if set, zero value otherwise.
+func (o *Field) GetReadOnly() (res FieldgetReadOnlyRetType) {
+	res, _ = o.GetReadOnlyOk()
+	return
+}
+
+// GetReadOnlyOk returns a tuple with the ReadOnly field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetReadOnlyOk() (ret FieldgetReadOnlyRetType, ok bool) {
+	return getFieldgetReadOnlyAttributeTypeOk(o.ReadOnly)
+}
+
+// HasReadOnly returns a boolean if a field has been set.
+func (o *Field) HasReadOnly() bool {
+	_, ok := o.GetReadOnlyOk()
+	return ok
+}
+
+// SetReadOnly gets a reference to the given bool and assigns it to the ReadOnly field.
+func (o *Field) SetReadOnly(v FieldgetReadOnlyRetType) {
+	setFieldgetReadOnlyAttributeType(&o.ReadOnly, v)
+}
+
+// GetTitle returns the Title field value if set, zero value otherwise.
+func (o *Field) GetTitle() (res FieldGetTitleRetType) {
+	res, _ = o.GetTitleOk()
+	return
+}
+
+// GetTitleOk returns a tuple with the Title field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Field) GetTitleOk() (ret FieldGetTitleRetType, ok bool) {
+	return getFieldGetTitleAttributeTypeOk(o.Title)
+}
+
+// HasTitle returns a boolean if a field has been set.
+func (o *Field) HasTitle() bool {
+	_, ok := o.GetTitleOk()
+	return ok
+}
+
+// SetTitle gets a reference to the given string and assigns it to the Title field.
+func (o *Field) SetTitle(v FieldGetTitleRetType) {
+	setFieldGetTitleAttributeType(&o.Title, v)
+}
+
+// GetType returns the Type field value if set, zero value otherwise.
+func (o *Field) GetType() (res FieldGetTypeRetType) {
+	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 *Field) GetTypeOk() (ret FieldGetTypeRetType, ok bool) {
+	return getFieldGetTypeAttributeTypeOk(o.Type)
+}
+
+// HasType returns a boolean if a field has been set.
+func (o *Field) HasType() bool {
+	_, ok := o.GetTypeOk()
+	return ok
+}
+
+// SetType gets a reference to the given string and assigns it to the Type field.
+func (o *Field) SetType(v FieldGetTypeRetType) {
+	setFieldGetTypeAttributeType(&o.Type, v)
+}
+
+func (o Field) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getFieldGetDefaultAttributeTypeOk(o.Default); ok {
+		toSerialize["Default"] = val
+	}
+	if val, ok := getFieldGetDescriptionAttributeTypeOk(o.Description); ok {
+		toSerialize["Description"] = val
+	}
+	if val, ok := getFieldGetMaxLenAttributeTypeOk(o.MaxLen); ok {
+		toSerialize["MaxLen"] = val
+	}
+	if val, ok := getFieldGetMinLenAttributeTypeOk(o.MinLen); ok {
+		toSerialize["MinLen"] = val
+	}
+	if val, ok := getFieldgetReadOnlyAttributeTypeOk(o.ReadOnly); ok {
+		toSerialize["ReadOnly"] = val
+	}
+	if val, ok := getFieldGetTitleAttributeTypeOk(o.Title); ok {
+		toSerialize["Title"] = val
+	}
+	if val, ok := getFieldGetTypeAttributeTypeOk(o.Type); ok {
+		toSerialize["Type"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableField struct {
+	value *Field
+	isSet bool
+}
+
+func (v NullableField) Get() *Field {
+	return v.value
+}
+
+func (v *NullableField) Set(val *Field) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableField) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableField) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableField(val *Field) *NullableField {
+	return &NullableField{value: val, isSet: true}
+}
+
+func (v NullableField) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableField) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_field_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_get_commands_response.go

@@ -0,0 +1,127 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the GetCommandsResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &GetCommandsResponse{}
+
+/*
+	types and functions for items
+*/
+
+// isArray
+type GetCommandsResponseGetItemsAttributeType = *[]Commands
+type GetCommandsResponseGetItemsArgType = []Commands
+type GetCommandsResponseGetItemsRetType = []Commands
+
+func getGetCommandsResponseGetItemsAttributeTypeOk(arg GetCommandsResponseGetItemsAttributeType) (ret GetCommandsResponseGetItemsRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setGetCommandsResponseGetItemsAttributeType(arg *GetCommandsResponseGetItemsAttributeType, val GetCommandsResponseGetItemsRetType) {
+	*arg = &val
+}
+
+// GetCommandsResponse struct for GetCommandsResponse
+type GetCommandsResponse struct {
+	Items GetCommandsResponseGetItemsAttributeType `json:"items,omitempty"`
+}
+
+// NewGetCommandsResponse instantiates a new GetCommandsResponse 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 NewGetCommandsResponse() *GetCommandsResponse {
+	this := GetCommandsResponse{}
+	return &this
+}
+
+// NewGetCommandsResponseWithDefaults instantiates a new GetCommandsResponse 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 NewGetCommandsResponseWithDefaults() *GetCommandsResponse {
+	this := GetCommandsResponse{}
+	return &this
+}
+
+// GetItems returns the Items field value if set, zero value otherwise.
+func (o *GetCommandsResponse) GetItems() (res GetCommandsResponseGetItemsRetType) {
+	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 *GetCommandsResponse) GetItemsOk() (ret GetCommandsResponseGetItemsRetType, ok bool) {
+	return getGetCommandsResponseGetItemsAttributeTypeOk(o.Items)
+}
+
+// HasItems returns a boolean if a field has been set.
+func (o *GetCommandsResponse) HasItems() bool {
+	_, ok := o.GetItemsOk()
+	return ok
+}
+
+// SetItems gets a reference to the given []Commands and assigns it to the Items field.
+func (o *GetCommandsResponse) SetItems(v GetCommandsResponseGetItemsRetType) {
+	setGetCommandsResponseGetItemsAttributeType(&o.Items, v)
+}
+
+func (o GetCommandsResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getGetCommandsResponseGetItemsAttributeTypeOk(o.Items); ok {
+		toSerialize["Items"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableGetCommandsResponse struct {
+	value *GetCommandsResponse
+	isSet bool
+}
+
+func (v NullableGetCommandsResponse) Get() *GetCommandsResponse {
+	return v.value
+}
+
+func (v *NullableGetCommandsResponse) Set(val *GetCommandsResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableGetCommandsResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableGetCommandsResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableGetCommandsResponse(val *GetCommandsResponse) *NullableGetCommandsResponse {
+	return &NullableGetCommandsResponse{value: val, isSet: true}
+}
+
+func (v NullableGetCommandsResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableGetCommandsResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_get_commands_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_new_command_response.go

@@ -0,0 +1,128 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the NewCommandResponse type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &NewCommandResponse{}
+
+/*
+	types and functions for id
+*/
+
+// isInteger
+type NewCommandResponseGetIdAttributeType = *int64
+type NewCommandResponseGetIdArgType = int64
+type NewCommandResponseGetIdRetType = int64
+
+func getNewCommandResponseGetIdAttributeTypeOk(arg NewCommandResponseGetIdAttributeType) (ret NewCommandResponseGetIdRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setNewCommandResponseGetIdAttributeType(arg *NewCommandResponseGetIdAttributeType, val NewCommandResponseGetIdRetType) {
+	*arg = &val
+}
+
+// NewCommandResponse struct for NewCommandResponse
+type NewCommandResponse struct {
+	// Can be cast to int32 without loss of precision.
+	Id NewCommandResponseGetIdAttributeType `json:"id,omitempty"`
+}
+
+// NewNewCommandResponse instantiates a new NewCommandResponse 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 NewNewCommandResponse() *NewCommandResponse {
+	this := NewCommandResponse{}
+	return &this
+}
+
+// NewNewCommandResponseWithDefaults instantiates a new NewCommandResponse 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 NewNewCommandResponseWithDefaults() *NewCommandResponse {
+	this := NewCommandResponse{}
+	return &this
+}
+
+// GetId returns the Id field value if set, zero value otherwise.
+func (o *NewCommandResponse) GetId() (res NewCommandResponseGetIdRetType) {
+	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 *NewCommandResponse) GetIdOk() (ret NewCommandResponseGetIdRetType, ok bool) {
+	return getNewCommandResponseGetIdAttributeTypeOk(o.Id)
+}
+
+// HasId returns a boolean if a field has been set.
+func (o *NewCommandResponse) HasId() bool {
+	_, ok := o.GetIdOk()
+	return ok
+}
+
+// SetId gets a reference to the given int64 and assigns it to the Id field.
+func (o *NewCommandResponse) SetId(v NewCommandResponseGetIdRetType) {
+	setNewCommandResponseGetIdAttributeType(&o.Id, v)
+}
+
+func (o NewCommandResponse) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getNewCommandResponseGetIdAttributeTypeOk(o.Id); ok {
+		toSerialize["Id"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableNewCommandResponse struct {
+	value *NewCommandResponse
+	isSet bool
+}
+
+func (v NullableNewCommandResponse) Get() *NewCommandResponse {
+	return v.value
+}
+
+func (v *NullableNewCommandResponse) Set(val *NewCommandResponse) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableNewCommandResponse) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableNewCommandResponse) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableNewCommandResponse(val *NewCommandResponse) *NullableNewCommandResponse {
+	return &NullableNewCommandResponse{value: val, isSet: true}
+}
+
+func (v NullableNewCommandResponse) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableNewCommandResponse) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_new_command_response_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_parameters_schema.go

@@ -0,0 +1,127 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the ParametersSchema type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &ParametersSchema{}
+
+/*
+	types and functions for properties
+*/
+
+// isModel
+type ParametersSchemaGetPropertiesAttributeType = *Properties
+type ParametersSchemaGetPropertiesArgType = Properties
+type ParametersSchemaGetPropertiesRetType = Properties
+
+func getParametersSchemaGetPropertiesAttributeTypeOk(arg ParametersSchemaGetPropertiesAttributeType) (ret ParametersSchemaGetPropertiesRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setParametersSchemaGetPropertiesAttributeType(arg *ParametersSchemaGetPropertiesAttributeType, val ParametersSchemaGetPropertiesRetType) {
+	*arg = &val
+}
+
+// ParametersSchema struct for ParametersSchema
+type ParametersSchema struct {
+	Properties ParametersSchemaGetPropertiesAttributeType `json:"properties,omitempty"`
+}
+
+// NewParametersSchema instantiates a new ParametersSchema 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 NewParametersSchema() *ParametersSchema {
+	this := ParametersSchema{}
+	return &this
+}
+
+// NewParametersSchemaWithDefaults instantiates a new ParametersSchema 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 NewParametersSchemaWithDefaults() *ParametersSchema {
+	this := ParametersSchema{}
+	return &this
+}
+
+// GetProperties returns the Properties field value if set, zero value otherwise.
+func (o *ParametersSchema) GetProperties() (res ParametersSchemaGetPropertiesRetType) {
+	res, _ = o.GetPropertiesOk()
+	return
+}
+
+// GetPropertiesOk returns a tuple with the Properties field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *ParametersSchema) GetPropertiesOk() (ret ParametersSchemaGetPropertiesRetType, ok bool) {
+	return getParametersSchemaGetPropertiesAttributeTypeOk(o.Properties)
+}
+
+// HasProperties returns a boolean if a field has been set.
+func (o *ParametersSchema) HasProperties() bool {
+	_, ok := o.GetPropertiesOk()
+	return ok
+}
+
+// SetProperties gets a reference to the given Properties and assigns it to the Properties field.
+func (o *ParametersSchema) SetProperties(v ParametersSchemaGetPropertiesRetType) {
+	setParametersSchemaGetPropertiesAttributeType(&o.Properties, v)
+}
+
+func (o ParametersSchema) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getParametersSchemaGetPropertiesAttributeTypeOk(o.Properties); ok {
+		toSerialize["Properties"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableParametersSchema struct {
+	value *ParametersSchema
+	isSet bool
+}
+
+func (v NullableParametersSchema) Get() *ParametersSchema {
+	return v.value
+}
+
+func (v *NullableParametersSchema) Set(val *ParametersSchema) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableParametersSchema) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableParametersSchema) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableParametersSchema(val *ParametersSchema) *NullableParametersSchema {
+	return &NullableParametersSchema{value: val, isSet: true}
+}
+
+func (v NullableParametersSchema) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableParametersSchema) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_parameters_schema_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/model_properties.go

@@ -0,0 +1,363 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+import (
+	"encoding/json"
+)
+
+// checks if the Properties type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &Properties{}
+
+/*
+	types and functions for ConfirmPassword
+*/
+
+// isModel
+type PropertiesGetConfirmPasswordAttributeType = *Field
+type PropertiesGetConfirmPasswordArgType = Field
+type PropertiesGetConfirmPasswordRetType = Field
+
+func getPropertiesGetConfirmPasswordAttributeTypeOk(arg PropertiesGetConfirmPasswordAttributeType) (ret PropertiesGetConfirmPasswordRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetConfirmPasswordAttributeType(arg *PropertiesGetConfirmPasswordAttributeType, val PropertiesGetConfirmPasswordRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for Password
+*/
+
+// isModel
+type PropertiesGetPasswordAttributeType = *Field
+type PropertiesGetPasswordArgType = Field
+type PropertiesGetPasswordRetType = Field
+
+func getPropertiesGetPasswordAttributeTypeOk(arg PropertiesGetPasswordAttributeType) (ret PropertiesGetPasswordRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetPasswordAttributeType(arg *PropertiesGetPasswordAttributeType, val PropertiesGetPasswordRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for Script
+*/
+
+// isModel
+type PropertiesGetScriptAttributeType = *Field
+type PropertiesGetScriptArgType = Field
+type PropertiesGetScriptRetType = Field
+
+func getPropertiesGetScriptAttributeTypeOk(arg PropertiesGetScriptAttributeType) (ret PropertiesGetScriptRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetScriptAttributeType(arg *PropertiesGetScriptAttributeType, val PropertiesGetScriptRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for Username
+*/
+
+// isModel
+type PropertiesGetUsernameAttributeType = *Field
+type PropertiesGetUsernameArgType = Field
+type PropertiesGetUsernameRetType = Field
+
+func getPropertiesGetUsernameAttributeTypeOk(arg PropertiesGetUsernameAttributeType) (ret PropertiesGetUsernameRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetUsernameAttributeType(arg *PropertiesGetUsernameAttributeType, val PropertiesGetUsernameRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for required
+*/
+
+// isArray
+type PropertiesGetRequiredAttributeType = *[]string
+type PropertiesGetRequiredArgType = []string
+type PropertiesGetRequiredRetType = []string
+
+func getPropertiesGetRequiredAttributeTypeOk(arg PropertiesGetRequiredAttributeType) (ret PropertiesGetRequiredRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetRequiredAttributeType(arg *PropertiesGetRequiredAttributeType, val PropertiesGetRequiredRetType) {
+	*arg = &val
+}
+
+/*
+	types and functions for type
+*/
+
+// isNotNullableString
+type PropertiesGetTypeAttributeType = *string
+
+func getPropertiesGetTypeAttributeTypeOk(arg PropertiesGetTypeAttributeType) (ret PropertiesGetTypeRetType, ok bool) {
+	if arg == nil {
+		return ret, false
+	}
+	return *arg, true
+}
+
+func setPropertiesGetTypeAttributeType(arg *PropertiesGetTypeAttributeType, val PropertiesGetTypeRetType) {
+	*arg = &val
+}
+
+type PropertiesGetTypeArgType = string
+type PropertiesGetTypeRetType = string
+
+// Properties struct for Properties
+type Properties struct {
+	ConfirmPassword PropertiesGetConfirmPasswordAttributeType `json:"ConfirmPassword,omitempty"`
+	Password        PropertiesGetPasswordAttributeType        `json:"Password,omitempty"`
+	Script          PropertiesGetScriptAttributeType          `json:"Script,omitempty"`
+	Username        PropertiesGetUsernameAttributeType        `json:"Username,omitempty"`
+	Required        PropertiesGetRequiredAttributeType        `json:"required,omitempty"`
+	Type            PropertiesGetTypeAttributeType            `json:"type,omitempty"`
+}
+
+// NewProperties instantiates a new Properties 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 NewProperties() *Properties {
+	this := Properties{}
+	return &this
+}
+
+// NewPropertiesWithDefaults instantiates a new Properties 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 NewPropertiesWithDefaults() *Properties {
+	this := Properties{}
+	return &this
+}
+
+// GetConfirmPassword returns the ConfirmPassword field value if set, zero value otherwise.
+func (o *Properties) GetConfirmPassword() (res PropertiesGetConfirmPasswordRetType) {
+	res, _ = o.GetConfirmPasswordOk()
+	return
+}
+
+// GetConfirmPasswordOk returns a tuple with the ConfirmPassword field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Properties) GetConfirmPasswordOk() (ret PropertiesGetConfirmPasswordRetType, ok bool) {
+	return getPropertiesGetConfirmPasswordAttributeTypeOk(o.ConfirmPassword)
+}
+
+// HasConfirmPassword returns a boolean if a field has been set.
+func (o *Properties) HasConfirmPassword() bool {
+	_, ok := o.GetConfirmPasswordOk()
+	return ok
+}
+
+// SetConfirmPassword gets a reference to the given Field and assigns it to the ConfirmPassword field.
+func (o *Properties) SetConfirmPassword(v PropertiesGetConfirmPasswordRetType) {
+	setPropertiesGetConfirmPasswordAttributeType(&o.ConfirmPassword, v)
+}
+
+// GetPassword returns the Password field value if set, zero value otherwise.
+func (o *Properties) GetPassword() (res PropertiesGetPasswordRetType) {
+	res, _ = o.GetPasswordOk()
+	return
+}
+
+// GetPasswordOk returns a tuple with the Password field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Properties) GetPasswordOk() (ret PropertiesGetPasswordRetType, ok bool) {
+	return getPropertiesGetPasswordAttributeTypeOk(o.Password)
+}
+
+// HasPassword returns a boolean if a field has been set.
+func (o *Properties) HasPassword() bool {
+	_, ok := o.GetPasswordOk()
+	return ok
+}
+
+// SetPassword gets a reference to the given Field and assigns it to the Password field.
+func (o *Properties) SetPassword(v PropertiesGetPasswordRetType) {
+	setPropertiesGetPasswordAttributeType(&o.Password, v)
+}
+
+// GetScript returns the Script field value if set, zero value otherwise.
+func (o *Properties) GetScript() (res PropertiesGetScriptRetType) {
+	res, _ = o.GetScriptOk()
+	return
+}
+
+// GetScriptOk returns a tuple with the Script field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Properties) GetScriptOk() (ret PropertiesGetScriptRetType, ok bool) {
+	return getPropertiesGetScriptAttributeTypeOk(o.Script)
+}
+
+// HasScript returns a boolean if a field has been set.
+func (o *Properties) HasScript() bool {
+	_, ok := o.GetScriptOk()
+	return ok
+}
+
+// SetScript gets a reference to the given Field and assigns it to the Script field.
+func (o *Properties) SetScript(v PropertiesGetScriptRetType) {
+	setPropertiesGetScriptAttributeType(&o.Script, v)
+}
+
+// GetUsername returns the Username field value if set, zero value otherwise.
+func (o *Properties) GetUsername() (res PropertiesGetUsernameRetType) {
+	res, _ = o.GetUsernameOk()
+	return
+}
+
+// GetUsernameOk returns a tuple with the Username field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Properties) GetUsernameOk() (ret PropertiesGetUsernameRetType, ok bool) {
+	return getPropertiesGetUsernameAttributeTypeOk(o.Username)
+}
+
+// HasUsername returns a boolean if a field has been set.
+func (o *Properties) HasUsername() bool {
+	_, ok := o.GetUsernameOk()
+	return ok
+}
+
+// SetUsername gets a reference to the given Field and assigns it to the Username field.
+func (o *Properties) SetUsername(v PropertiesGetUsernameRetType) {
+	setPropertiesGetUsernameAttributeType(&o.Username, v)
+}
+
+// GetRequired returns the Required field value if set, zero value otherwise.
+func (o *Properties) GetRequired() (res PropertiesGetRequiredRetType) {
+	res, _ = o.GetRequiredOk()
+	return
+}
+
+// GetRequiredOk returns a tuple with the Required field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *Properties) GetRequiredOk() (ret PropertiesGetRequiredRetType, ok bool) {
+	return getPropertiesGetRequiredAttributeTypeOk(o.Required)
+}
+
+// HasRequired returns a boolean if a field has been set.
+func (o *Properties) HasRequired() bool {
+	_, ok := o.GetRequiredOk()
+	return ok
+}
+
+// SetRequired gets a reference to the given []string and assigns it to the Required field.
+func (o *Properties) SetRequired(v PropertiesGetRequiredRetType) {
+	setPropertiesGetRequiredAttributeType(&o.Required, v)
+}
+
+// GetType returns the Type field value if set, zero value otherwise.
+func (o *Properties) GetType() (res PropertiesGetTypeRetType) {
+	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 *Properties) GetTypeOk() (ret PropertiesGetTypeRetType, ok bool) {
+	return getPropertiesGetTypeAttributeTypeOk(o.Type)
+}
+
+// HasType returns a boolean if a field has been set.
+func (o *Properties) HasType() bool {
+	_, ok := o.GetTypeOk()
+	return ok
+}
+
+// SetType gets a reference to the given string and assigns it to the Type field.
+func (o *Properties) SetType(v PropertiesGetTypeRetType) {
+	setPropertiesGetTypeAttributeType(&o.Type, v)
+}
+
+func (o Properties) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if val, ok := getPropertiesGetConfirmPasswordAttributeTypeOk(o.ConfirmPassword); ok {
+		toSerialize["ConfirmPassword"] = val
+	}
+	if val, ok := getPropertiesGetPasswordAttributeTypeOk(o.Password); ok {
+		toSerialize["Password"] = val
+	}
+	if val, ok := getPropertiesGetScriptAttributeTypeOk(o.Script); ok {
+		toSerialize["Script"] = val
+	}
+	if val, ok := getPropertiesGetUsernameAttributeTypeOk(o.Username); ok {
+		toSerialize["Username"] = val
+	}
+	if val, ok := getPropertiesGetRequiredAttributeTypeOk(o.Required); ok {
+		toSerialize["Required"] = val
+	}
+	if val, ok := getPropertiesGetTypeAttributeTypeOk(o.Type); ok {
+		toSerialize["Type"] = val
+	}
+	return toSerialize, nil
+}
+
+type NullableProperties struct {
+	value *Properties
+	isSet bool
+}
+
+func (v NullableProperties) Get() *Properties {
+	return v.value
+}
+
+func (v *NullableProperties) Set(val *Properties) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableProperties) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableProperties) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableProperties(val *Properties) *NullableProperties {
+	return &NullableProperties{value: val, isSet: true}
+}
+
+func (v NullableProperties) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableProperties) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

pkg/runcommandbeta/model_properties_test.go

@@ -0,0 +1,11 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta

pkg/runcommandbeta/utils.go

@@ -0,0 +1,385 @@
+/*
+STACKIT Run Commands Service API
+
+API endpoints for the STACKIT Run Commands Service API
+
+API version: 2beta.0
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package runcommandbeta
+
+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)
+}