github.com/NaverCloudPlatform/ncloud-sdk-go-v2@v1.6.13/services/vnks/v2_api.go (about)

     1  /*
     2   * vnks
     3   *
     4   * <br/>https://nks.apigw.ntruss.com/vnks/v2
     5   *
     6   * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
     7   */
     8  
     9  package vnks
    10  
    11  import (
    12  	"context"
    13  	"encoding/base64"
    14  	"encoding/json"
    15  	"fmt"
    16  	"io/ioutil"
    17  	"net/url"
    18  	"reflect"
    19  	"strings"
    20  )
    21  
    22  // Linger please
    23  var (
    24  	_ context.Context
    25  )
    26  
    27  type V2ApiService service
    28  
    29  /* V2ApiService
    30  @return *ClustersRes*/
    31  func (a *V2ApiService) ClustersGet(ctx context.Context) (*ClustersRes, error) {
    32  	var (
    33  		localVarHttpMethod = strings.ToUpper("Get")
    34  		localVarPostBody   interface{}
    35  		localVarFileName   string
    36  		localVarFileBytes  []byte
    37  		successPayload     ClustersRes
    38  	)
    39  
    40  	// create path and map variables
    41  	localVarPath := a.client.cfg.BasePath + "/clusters"
    42  
    43  	localVarHeaderParams := make(map[string]string)
    44  	localVarQueryParams := url.Values{}
    45  	localVarFormParams := url.Values{}
    46  
    47  	// to determine the Content-Type header
    48  	localVarHttpContentTypes := []string{"application/json"}
    49  
    50  	// set Content-Type header
    51  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    52  	if localVarHttpContentType != "" {
    53  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    54  	}
    55  
    56  	// to determine the Accept header
    57  	localVarHttpHeaderAccepts := []string{
    58  		"application/json",
    59  	}
    60  
    61  	// set Accept header
    62  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    63  	if localVarHttpHeaderAccept != "" {
    64  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    65  	}
    66  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    67  	if err != nil {
    68  		return &successPayload, err
    69  	}
    70  
    71  	localVarHttpResponse, err := a.client.callAPI(r)
    72  	if err != nil || localVarHttpResponse == nil {
    73  		return &successPayload, err
    74  	}
    75  	defer localVarHttpResponse.Body.Close()
    76  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
    77  
    78  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
    79  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
    80  	}
    81  
    82  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
    83  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
    84  			return &successPayload, err
    85  		}
    86  	}
    87  
    88  	return &successPayload, err
    89  }
    90  
    91  /* V2ApiService
    92  @param body
    93  @return *CreateClusterRes*/
    94  func (a *V2ApiService) ClustersPost(ctx context.Context, body *ClusterInputBody) (*CreateClusterRes, error) {
    95  	var (
    96  		localVarHttpMethod = strings.ToUpper("Post")
    97  		localVarPostBody   interface{}
    98  		localVarFileName   string
    99  		localVarFileBytes  []byte
   100  		successPayload     CreateClusterRes
   101  	)
   102  
   103  	// create path and map variables
   104  	localVarPath := a.client.cfg.BasePath + "/clusters"
   105  
   106  	localVarHeaderParams := make(map[string]string)
   107  	localVarQueryParams := url.Values{}
   108  	localVarFormParams := url.Values{}
   109  
   110  	// to determine the Content-Type header
   111  	localVarHttpContentTypes := []string{"application/json"}
   112  
   113  	// set Content-Type header
   114  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   115  	if localVarHttpContentType != "" {
   116  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   117  	}
   118  
   119  	// to determine the Accept header
   120  	localVarHttpHeaderAccepts := []string{
   121  		"application/json",
   122  	}
   123  
   124  	// set Accept header
   125  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   126  	if localVarHttpHeaderAccept != "" {
   127  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   128  	}
   129  	// body params
   130  	localVarPostBody = body
   131  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   132  	if v.IsValid() && v.CanAddr() {
   133  		ptr := v.Addr().Interface().(**string)
   134  		if *ptr != nil {
   135  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   136  		}
   137  	}
   138  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   139  	if err != nil {
   140  		return &successPayload, err
   141  	}
   142  
   143  	localVarHttpResponse, err := a.client.callAPI(r)
   144  	if err != nil || localVarHttpResponse == nil {
   145  		return &successPayload, err
   146  	}
   147  	defer localVarHttpResponse.Body.Close()
   148  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   149  
   150  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   151  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   152  	}
   153  
   154  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   155  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   156  			return &successPayload, err
   157  		}
   158  	}
   159  
   160  	return &successPayload, err
   161  }
   162  
   163  /* V2ApiService
   164  @param body
   165  @param uuid uuid
   166  @return *UpdateClusterRes*/
   167  func (a *V2ApiService) ClustersUuidAddSubnetPatch(ctx context.Context, body *AddSubnetDto, uuid *string) (*UpdateClusterRes, error) {
   168  	var (
   169  		localVarHttpMethod = strings.ToUpper("Patch")
   170  		localVarPostBody   interface{}
   171  		localVarFileName   string
   172  		localVarFileBytes  []byte
   173  		successPayload     UpdateClusterRes
   174  	)
   175  
   176  	// create path and map variables
   177  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/add-subnet"
   178  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   179  
   180  	localVarHeaderParams := make(map[string]string)
   181  	localVarQueryParams := url.Values{}
   182  	localVarFormParams := url.Values{}
   183  
   184  	// to determine the Content-Type header
   185  	localVarHttpContentTypes := []string{"application/json"}
   186  
   187  	// set Content-Type header
   188  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   189  	if localVarHttpContentType != "" {
   190  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   191  	}
   192  
   193  	// to determine the Accept header
   194  	localVarHttpHeaderAccepts := []string{
   195  		"application/json",
   196  	}
   197  
   198  	// set Accept header
   199  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   200  	if localVarHttpHeaderAccept != "" {
   201  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   202  	}
   203  	// body params
   204  	localVarPostBody = body
   205  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   206  	if v.IsValid() && v.CanAddr() {
   207  		ptr := v.Addr().Interface().(**string)
   208  		if *ptr != nil {
   209  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   210  		}
   211  	}
   212  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   213  	if err != nil {
   214  		return &successPayload, err
   215  	}
   216  
   217  	localVarHttpResponse, err := a.client.callAPI(r)
   218  	if err != nil || localVarHttpResponse == nil {
   219  		return &successPayload, err
   220  	}
   221  	defer localVarHttpResponse.Body.Close()
   222  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   223  
   224  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   225  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   226  	}
   227  
   228  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   229  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   230  			return &successPayload, err
   231  		}
   232  	}
   233  
   234  	return &successPayload, err
   235  }
   236  
   237  /* V2ApiService
   238  @param uuid uuid
   239  @return */
   240  func (a *V2ApiService) ClustersUuidDelete(ctx context.Context, uuid *string) error {
   241  	var (
   242  		localVarHttpMethod = strings.ToUpper("Delete")
   243  		localVarPostBody   interface{}
   244  		localVarFileName   string
   245  		localVarFileBytes  []byte
   246  	)
   247  
   248  	// create path and map variables
   249  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}"
   250  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   251  
   252  	localVarHeaderParams := make(map[string]string)
   253  	localVarQueryParams := url.Values{}
   254  	localVarFormParams := url.Values{}
   255  
   256  	// to determine the Content-Type header
   257  	localVarHttpContentTypes := []string{"application/json"}
   258  
   259  	// set Content-Type header
   260  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   261  	if localVarHttpContentType != "" {
   262  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   263  	}
   264  
   265  	// to determine the Accept header
   266  	localVarHttpHeaderAccepts := []string{
   267  		"application/json",
   268  	}
   269  
   270  	// set Accept header
   271  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   272  	if localVarHttpHeaderAccept != "" {
   273  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   274  	}
   275  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   276  	if err != nil {
   277  		return err
   278  	}
   279  
   280  	localVarHttpResponse, err := a.client.callAPI(r)
   281  	if err != nil || localVarHttpResponse == nil {
   282  		return err
   283  	}
   284  	defer localVarHttpResponse.Body.Close()
   285  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   286  
   287  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   288  		return reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   289  	}
   290  
   291  	return err
   292  }
   293  
   294  /* V2ApiService
   295  @param uuid uuid
   296  @return *ClusterRes*/
   297  func (a *V2ApiService) ClustersUuidGet(ctx context.Context, uuid *string) (*ClusterRes, error) {
   298  	var (
   299  		localVarHttpMethod = strings.ToUpper("Get")
   300  		localVarPostBody   interface{}
   301  		localVarFileName   string
   302  		localVarFileBytes  []byte
   303  		successPayload     ClusterRes
   304  	)
   305  
   306  	// create path and map variables
   307  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}"
   308  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   309  
   310  	localVarHeaderParams := make(map[string]string)
   311  	localVarQueryParams := url.Values{}
   312  	localVarFormParams := url.Values{}
   313  
   314  	// to determine the Content-Type header
   315  	localVarHttpContentTypes := []string{"application/json"}
   316  
   317  	// set Content-Type header
   318  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   319  	if localVarHttpContentType != "" {
   320  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   321  	}
   322  
   323  	// to determine the Accept header
   324  	localVarHttpHeaderAccepts := []string{
   325  		"application/json",
   326  	}
   327  
   328  	// set Accept header
   329  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   330  	if localVarHttpHeaderAccept != "" {
   331  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   332  	}
   333  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   334  	if err != nil {
   335  		return &successPayload, err
   336  	}
   337  
   338  	localVarHttpResponse, err := a.client.callAPI(r)
   339  	if err != nil || localVarHttpResponse == nil {
   340  		return &successPayload, err
   341  	}
   342  	defer localVarHttpResponse.Body.Close()
   343  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   344  
   345  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   346  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   347  	}
   348  
   349  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   350  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   351  			return &successPayload, err
   352  		}
   353  	}
   354  
   355  	return &successPayload, err
   356  }
   357  
   358  /* V2ApiService
   359  @param uuid uuid
   360  @return *IpAclsRes*/
   361  func (a *V2ApiService) ClustersUuidIpAclGet(ctx context.Context, uuid *string) (*IpAclsRes, error) {
   362  	var (
   363  		localVarHttpMethod = strings.ToUpper("Get")
   364  		localVarPostBody   interface{}
   365  		localVarFileName   string
   366  		localVarFileBytes  []byte
   367  		successPayload     IpAclsRes
   368  	)
   369  
   370  	// create path and map variables
   371  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/ip-acl"
   372  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   373  
   374  	localVarHeaderParams := make(map[string]string)
   375  	localVarQueryParams := url.Values{}
   376  	localVarFormParams := url.Values{}
   377  
   378  	// to determine the Content-Type header
   379  	localVarHttpContentTypes := []string{"application/json"}
   380  
   381  	// set Content-Type header
   382  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   383  	if localVarHttpContentType != "" {
   384  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   385  	}
   386  
   387  	// to determine the Accept header
   388  	localVarHttpHeaderAccepts := []string{
   389  		"application/json",
   390  	}
   391  
   392  	// set Accept header
   393  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   394  	if localVarHttpHeaderAccept != "" {
   395  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   396  	}
   397  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   398  	if err != nil {
   399  		return &successPayload, err
   400  	}
   401  
   402  	localVarHttpResponse, err := a.client.callAPI(r)
   403  	if err != nil || localVarHttpResponse == nil {
   404  		return &successPayload, err
   405  	}
   406  	defer localVarHttpResponse.Body.Close()
   407  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   408  
   409  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   410  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   411  	}
   412  
   413  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   414  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   415  			return &successPayload, err
   416  		}
   417  	}
   418  
   419  	return &successPayload, err
   420  }
   421  
   422  /* V2ApiService
   423  @param body
   424  @param uuid uuid
   425  @return *UpdateClusterRes*/
   426  func (a *V2ApiService) ClustersUuidIpAclPatch(ctx context.Context, body *IpAclsDto, uuid *string) (*UpdateClusterRes, error) {
   427  	var (
   428  		localVarHttpMethod = strings.ToUpper("Patch")
   429  		localVarPostBody   interface{}
   430  		localVarFileName   string
   431  		localVarFileBytes  []byte
   432  		successPayload     UpdateClusterRes
   433  	)
   434  
   435  	// create path and map variables
   436  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/ip-acl"
   437  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   438  
   439  	localVarHeaderParams := make(map[string]string)
   440  	localVarQueryParams := url.Values{}
   441  	localVarFormParams := url.Values{}
   442  
   443  	// to determine the Content-Type header
   444  	localVarHttpContentTypes := []string{"application/json"}
   445  
   446  	// set Content-Type header
   447  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   448  	if localVarHttpContentType != "" {
   449  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   450  	}
   451  
   452  	// to determine the Accept header
   453  	localVarHttpHeaderAccepts := []string{
   454  		"application/json",
   455  	}
   456  
   457  	// set Accept header
   458  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   459  	if localVarHttpHeaderAccept != "" {
   460  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   461  	}
   462  	// body params
   463  	localVarPostBody = body
   464  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   465  	if v.IsValid() && v.CanAddr() {
   466  		ptr := v.Addr().Interface().(**string)
   467  		if *ptr != nil {
   468  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   469  		}
   470  	}
   471  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   472  	if err != nil {
   473  		return &successPayload, err
   474  	}
   475  
   476  	localVarHttpResponse, err := a.client.callAPI(r)
   477  	if err != nil || localVarHttpResponse == nil {
   478  		return &successPayload, err
   479  	}
   480  	defer localVarHttpResponse.Body.Close()
   481  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   482  
   483  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   484  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   485  	}
   486  
   487  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   488  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   489  			return &successPayload, err
   490  		}
   491  	}
   492  
   493  	return &successPayload, err
   494  }
   495  
   496  /* V2ApiService
   497  @param uuid uuid
   498  @return *KubeconfigRes*/
   499  func (a *V2ApiService) ClustersUuidKubeconfigGet(ctx context.Context, uuid *string) (*KubeconfigRes, error) {
   500  	var (
   501  		localVarHttpMethod = strings.ToUpper("Get")
   502  		localVarPostBody   interface{}
   503  		localVarFileName   string
   504  		localVarFileBytes  []byte
   505  		successPayload     KubeconfigRes
   506  	)
   507  
   508  	// create path and map variables
   509  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/kubeconfig"
   510  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   511  
   512  	localVarHeaderParams := make(map[string]string)
   513  	localVarQueryParams := url.Values{}
   514  	localVarFormParams := url.Values{}
   515  
   516  	// to determine the Content-Type header
   517  	localVarHttpContentTypes := []string{"application/json"}
   518  
   519  	// set Content-Type header
   520  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   521  	if localVarHttpContentType != "" {
   522  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   523  	}
   524  
   525  	// to determine the Accept header
   526  	localVarHttpHeaderAccepts := []string{
   527  		"application/json",
   528  	}
   529  
   530  	// set Accept header
   531  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   532  	if localVarHttpHeaderAccept != "" {
   533  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   534  	}
   535  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   536  	if err != nil {
   537  		return &successPayload, err
   538  	}
   539  
   540  	localVarHttpResponse, err := a.client.callAPI(r)
   541  	if err != nil || localVarHttpResponse == nil {
   542  		return &successPayload, err
   543  	}
   544  	defer localVarHttpResponse.Body.Close()
   545  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   546  
   547  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   548  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   549  	}
   550  
   551  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   552  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   553  			return &successPayload, err
   554  		}
   555  	}
   556  
   557  	return &successPayload, err
   558  }
   559  
   560  /* V2ApiService
   561  @param uuid uuid
   562  @return *UpdateClusterRes*/
   563  func (a *V2ApiService) ClustersUuidKubeconfigResetPatch(ctx context.Context, uuid *string) (*UpdateClusterRes, error) {
   564  	var (
   565  		localVarHttpMethod = strings.ToUpper("Patch")
   566  		localVarPostBody   interface{}
   567  		localVarFileName   string
   568  		localVarFileBytes  []byte
   569  		successPayload     UpdateClusterRes
   570  	)
   571  
   572  	// create path and map variables
   573  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/kubeconfig/reset"
   574  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   575  
   576  	localVarHeaderParams := make(map[string]string)
   577  	localVarQueryParams := url.Values{}
   578  	localVarFormParams := url.Values{}
   579  
   580  	// to determine the Content-Type header
   581  	localVarHttpContentTypes := []string{"application/json"}
   582  
   583  	// set Content-Type header
   584  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   585  	if localVarHttpContentType != "" {
   586  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   587  	}
   588  
   589  	// to determine the Accept header
   590  	localVarHttpHeaderAccepts := []string{
   591  		"application/json",
   592  	}
   593  
   594  	// set Accept header
   595  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   596  	if localVarHttpHeaderAccept != "" {
   597  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   598  	}
   599  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   600  	if err != nil {
   601  		return &successPayload, err
   602  	}
   603  
   604  	localVarHttpResponse, err := a.client.callAPI(r)
   605  	if err != nil || localVarHttpResponse == nil {
   606  		return &successPayload, err
   607  	}
   608  	defer localVarHttpResponse.Body.Close()
   609  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   610  
   611  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   612  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   613  	}
   614  
   615  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   616  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   617  			return &successPayload, err
   618  		}
   619  	}
   620  
   621  	return &successPayload, err
   622  }
   623  
   624  /* V2ApiService
   625  @param uuid uuid
   626  @param lbSubnetNo
   627  @param optional (nil or map[string]interface{}) with one or more of:
   628      @param "igwYn" (string)
   629  @return *UpdateClusterLbSubnetRes*/
   630  func (a *V2ApiService) ClustersUuidLbSubnetPatch(ctx context.Context, uuid *string, lbSubnetNo *int32, localVarOptionals map[string]interface{}) (*UpdateClusterLbSubnetRes, error) {
   631  	var (
   632  		localVarHttpMethod = strings.ToUpper("Patch")
   633  		localVarPostBody   interface{}
   634  		localVarFileName   string
   635  		localVarFileBytes  []byte
   636  		successPayload     UpdateClusterLbSubnetRes
   637  	)
   638  
   639  	// create path and map variables
   640  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/lb-subnet"
   641  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   642  
   643  	localVarHeaderParams := make(map[string]string)
   644  	localVarQueryParams := url.Values{}
   645  	localVarFormParams := url.Values{}
   646  	if err := typeCheckParameter(localVarOptionals["igwYn"], "*string", "igwYn"); err != nil {
   647  		return &successPayload, err
   648  	}
   649  
   650  	if localVarTempParam, localVarOk := localVarOptionals["igwYn"].(*string); localVarOk {
   651  		localVarQueryParams.Add("igwYn", parameterToString(*localVarTempParam, ""))
   652  	}
   653  	localVarQueryParams.Add("lbSubnetNo", parameterToString(*lbSubnetNo, ""))
   654  	// to determine the Content-Type header
   655  	localVarHttpContentTypes := []string{"application/json"}
   656  
   657  	// set Content-Type header
   658  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   659  	if localVarHttpContentType != "" {
   660  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   661  	}
   662  
   663  	// to determine the Accept header
   664  	localVarHttpHeaderAccepts := []string{
   665  		"application/json",
   666  	}
   667  
   668  	// set Accept header
   669  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   670  	if localVarHttpHeaderAccept != "" {
   671  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   672  	}
   673  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   674  	if err != nil {
   675  		return &successPayload, err
   676  	}
   677  
   678  	localVarHttpResponse, err := a.client.callAPI(r)
   679  	if err != nil || localVarHttpResponse == nil {
   680  		return &successPayload, err
   681  	}
   682  	defer localVarHttpResponse.Body.Close()
   683  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   684  
   685  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   686  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   687  	}
   688  
   689  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   690  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   691  			return &successPayload, err
   692  		}
   693  	}
   694  
   695  	return &successPayload, err
   696  }
   697  
   698  /* V2ApiService
   699  @param body
   700  @param uuid uuid
   701  @return *UpdateClusterRes*/
   702  func (a *V2ApiService) ClustersUuidLogPatch(ctx context.Context, body *AuditLogDto, uuid *string) (*UpdateClusterRes, error) {
   703  	var (
   704  		localVarHttpMethod = strings.ToUpper("Patch")
   705  		localVarPostBody   interface{}
   706  		localVarFileName   string
   707  		localVarFileBytes  []byte
   708  		successPayload     UpdateClusterRes
   709  	)
   710  
   711  	// create path and map variables
   712  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/log"
   713  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   714  
   715  	localVarHeaderParams := make(map[string]string)
   716  	localVarQueryParams := url.Values{}
   717  	localVarFormParams := url.Values{}
   718  
   719  	// to determine the Content-Type header
   720  	localVarHttpContentTypes := []string{"application/json"}
   721  
   722  	// set Content-Type header
   723  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   724  	if localVarHttpContentType != "" {
   725  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   726  	}
   727  
   728  	// to determine the Accept header
   729  	localVarHttpHeaderAccepts := []string{
   730  		"application/json",
   731  	}
   732  
   733  	// set Accept header
   734  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   735  	if localVarHttpHeaderAccept != "" {
   736  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   737  	}
   738  	// body params
   739  	localVarPostBody = body
   740  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   741  	if v.IsValid() && v.CanAddr() {
   742  		ptr := v.Addr().Interface().(**string)
   743  		if *ptr != nil {
   744  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   745  		}
   746  	}
   747  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   748  	if err != nil {
   749  		return &successPayload, err
   750  	}
   751  
   752  	localVarHttpResponse, err := a.client.callAPI(r)
   753  	if err != nil || localVarHttpResponse == nil {
   754  		return &successPayload, err
   755  	}
   756  	defer localVarHttpResponse.Body.Close()
   757  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   758  
   759  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   760  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   761  	}
   762  
   763  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   764  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   765  			return &successPayload, err
   766  		}
   767  	}
   768  
   769  	return &successPayload, err
   770  }
   771  
   772  /* V2ApiService
   773  @param uuid uuid
   774  @return *NodePoolRes*/
   775  func (a *V2ApiService) ClustersUuidNodePoolGet(ctx context.Context, uuid *string) (*NodePoolRes, error) {
   776  	var (
   777  		localVarHttpMethod = strings.ToUpper("Get")
   778  		localVarPostBody   interface{}
   779  		localVarFileName   string
   780  		localVarFileBytes  []byte
   781  		successPayload     NodePoolRes
   782  	)
   783  
   784  	// create path and map variables
   785  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool"
   786  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   787  
   788  	localVarHeaderParams := make(map[string]string)
   789  	localVarQueryParams := url.Values{}
   790  	localVarFormParams := url.Values{}
   791  
   792  	// to determine the Content-Type header
   793  	localVarHttpContentTypes := []string{"application/json"}
   794  
   795  	// set Content-Type header
   796  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   797  	if localVarHttpContentType != "" {
   798  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   799  	}
   800  
   801  	// to determine the Accept header
   802  	localVarHttpHeaderAccepts := []string{
   803  		"application/json",
   804  	}
   805  
   806  	// set Accept header
   807  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   808  	if localVarHttpHeaderAccept != "" {
   809  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   810  	}
   811  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   812  	if err != nil {
   813  		return &successPayload, err
   814  	}
   815  
   816  	localVarHttpResponse, err := a.client.callAPI(r)
   817  	if err != nil || localVarHttpResponse == nil {
   818  		return &successPayload, err
   819  	}
   820  	defer localVarHttpResponse.Body.Close()
   821  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   822  
   823  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   824  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   825  	}
   826  
   827  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   828  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   829  			return &successPayload, err
   830  		}
   831  	}
   832  
   833  	return &successPayload, err
   834  }
   835  
   836  /* V2ApiService
   837  @param uuid uuid
   838  @param instanceNo instanceNo
   839  @return */
   840  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoDelete(ctx context.Context, uuid *string, instanceNo *string) error {
   841  	var (
   842  		localVarHttpMethod = strings.ToUpper("Delete")
   843  		localVarPostBody   interface{}
   844  		localVarFileName   string
   845  		localVarFileBytes  []byte
   846  	)
   847  
   848  	// create path and map variables
   849  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}"
   850  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   851  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
   852  
   853  	localVarHeaderParams := make(map[string]string)
   854  	localVarQueryParams := url.Values{}
   855  	localVarFormParams := url.Values{}
   856  
   857  	// to determine the Content-Type header
   858  	localVarHttpContentTypes := []string{"application/json"}
   859  
   860  	// set Content-Type header
   861  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   862  	if localVarHttpContentType != "" {
   863  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   864  	}
   865  
   866  	// to determine the Accept header
   867  	localVarHttpHeaderAccepts := []string{
   868  		"application/json",
   869  	}
   870  
   871  	// set Accept header
   872  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   873  	if localVarHttpHeaderAccept != "" {
   874  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   875  	}
   876  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   877  	if err != nil {
   878  		return err
   879  	}
   880  
   881  	localVarHttpResponse, err := a.client.callAPI(r)
   882  	if err != nil || localVarHttpResponse == nil {
   883  		return err
   884  	}
   885  	defer localVarHttpResponse.Body.Close()
   886  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   887  
   888  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   889  		return reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   890  	}
   891  
   892  	return err
   893  }
   894  
   895  /* V2ApiService
   896  @param body
   897  @param uuid uuid
   898  @param instanceNo instanceNo
   899  @return *UpdateNodePoolRes*/
   900  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoLabelsPut(ctx context.Context, body *UpdateNodepoolLabelDto, uuid *string, instanceNo *string) (*UpdateNodePoolRes, error) {
   901  	var (
   902  		localVarHttpMethod = strings.ToUpper("Put")
   903  		localVarPostBody   interface{}
   904  		localVarFileName   string
   905  		localVarFileBytes  []byte
   906  		successPayload     UpdateNodePoolRes
   907  	)
   908  
   909  	// create path and map variables
   910  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}/labels"
   911  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   912  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
   913  
   914  	localVarHeaderParams := make(map[string]string)
   915  	localVarQueryParams := url.Values{}
   916  	localVarFormParams := url.Values{}
   917  
   918  	// to determine the Content-Type header
   919  	localVarHttpContentTypes := []string{"application/json"}
   920  
   921  	// set Content-Type header
   922  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   923  	if localVarHttpContentType != "" {
   924  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   925  	}
   926  
   927  	// to determine the Accept header
   928  	localVarHttpHeaderAccepts := []string{
   929  		"application/json",
   930  	}
   931  
   932  	// set Accept header
   933  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   934  	if localVarHttpHeaderAccept != "" {
   935  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   936  	}
   937  	// body params
   938  	localVarPostBody = body
   939  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   940  	if v.IsValid() && v.CanAddr() {
   941  		ptr := v.Addr().Interface().(**string)
   942  		if *ptr != nil {
   943  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   944  		}
   945  	}
   946  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   947  	if err != nil {
   948  		return &successPayload, err
   949  	}
   950  
   951  	localVarHttpResponse, err := a.client.callAPI(r)
   952  	if err != nil || localVarHttpResponse == nil {
   953  		return &successPayload, err
   954  	}
   955  	defer localVarHttpResponse.Body.Close()
   956  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   957  
   958  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
   959  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   960  	}
   961  
   962  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
   963  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
   964  			return &successPayload, err
   965  		}
   966  	}
   967  
   968  	return &successPayload, err
   969  }
   970  
   971  /* V2ApiService
   972  @param body
   973  @param uuid uuid
   974  @param instanceNo instanceNo
   975  @return */
   976  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoPatch(ctx context.Context, body *NodePoolUpdateBody, uuid *string, instanceNo *string) error {
   977  	var (
   978  		localVarHttpMethod = strings.ToUpper("Patch")
   979  		localVarPostBody   interface{}
   980  		localVarFileName   string
   981  		localVarFileBytes  []byte
   982  	)
   983  
   984  	// create path and map variables
   985  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}"
   986  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
   987  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
   988  
   989  	localVarHeaderParams := make(map[string]string)
   990  	localVarQueryParams := url.Values{}
   991  	localVarFormParams := url.Values{}
   992  
   993  	// to determine the Content-Type header
   994  	localVarHttpContentTypes := []string{"application/json"}
   995  
   996  	// set Content-Type header
   997  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   998  	if localVarHttpContentType != "" {
   999  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1000  	}
  1001  
  1002  	// to determine the Accept header
  1003  	localVarHttpHeaderAccepts := []string{
  1004  		"application/json",
  1005  	}
  1006  
  1007  	// set Accept header
  1008  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1009  	if localVarHttpHeaderAccept != "" {
  1010  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1011  	}
  1012  	// body params
  1013  	localVarPostBody = body
  1014  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1015  	if v.IsValid() && v.CanAddr() {
  1016  		ptr := v.Addr().Interface().(**string)
  1017  		if *ptr != nil {
  1018  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1019  		}
  1020  	}
  1021  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1022  	if err != nil {
  1023  		return err
  1024  	}
  1025  
  1026  	localVarHttpResponse, err := a.client.callAPI(r)
  1027  	if err != nil || localVarHttpResponse == nil {
  1028  		return err
  1029  	}
  1030  	defer localVarHttpResponse.Body.Close()
  1031  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1032  
  1033  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1034  		return reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1035  	}
  1036  
  1037  	return err
  1038  }
  1039  
  1040  /* V2ApiService
  1041  @param body
  1042  @param uuid uuid
  1043  @param instanceNo instanceNo
  1044  @return *UpdateNodePoolRes*/
  1045  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoSubnetsPatch(ctx context.Context, body *UpdateNodepoolSubnetDto, uuid *string, instanceNo *string) (*UpdateNodePoolRes, error) {
  1046  	var (
  1047  		localVarHttpMethod = strings.ToUpper("Patch")
  1048  		localVarPostBody   interface{}
  1049  		localVarFileName   string
  1050  		localVarFileBytes  []byte
  1051  		successPayload     UpdateNodePoolRes
  1052  	)
  1053  
  1054  	// create path and map variables
  1055  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}/subnets"
  1056  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1057  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
  1058  
  1059  	localVarHeaderParams := make(map[string]string)
  1060  	localVarQueryParams := url.Values{}
  1061  	localVarFormParams := url.Values{}
  1062  
  1063  	// to determine the Content-Type header
  1064  	localVarHttpContentTypes := []string{"application/json"}
  1065  
  1066  	// set Content-Type header
  1067  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1068  	if localVarHttpContentType != "" {
  1069  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1070  	}
  1071  
  1072  	// to determine the Accept header
  1073  	localVarHttpHeaderAccepts := []string{
  1074  		"application/json",
  1075  	}
  1076  
  1077  	// set Accept header
  1078  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1079  	if localVarHttpHeaderAccept != "" {
  1080  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1081  	}
  1082  	// body params
  1083  	localVarPostBody = body
  1084  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1085  	if v.IsValid() && v.CanAddr() {
  1086  		ptr := v.Addr().Interface().(**string)
  1087  		if *ptr != nil {
  1088  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1089  		}
  1090  	}
  1091  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1092  	if err != nil {
  1093  		return &successPayload, err
  1094  	}
  1095  
  1096  	localVarHttpResponse, err := a.client.callAPI(r)
  1097  	if err != nil || localVarHttpResponse == nil {
  1098  		return &successPayload, err
  1099  	}
  1100  	defer localVarHttpResponse.Body.Close()
  1101  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1102  
  1103  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1104  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1105  	}
  1106  
  1107  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1108  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1109  			return &successPayload, err
  1110  		}
  1111  	}
  1112  
  1113  	return &successPayload, err
  1114  }
  1115  
  1116  /* V2ApiService
  1117  @param body
  1118  @param uuid uuid
  1119  @param instanceNo instanceNo
  1120  @return *UpdateNodePoolRes*/
  1121  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoTaintsPut(ctx context.Context, body *UpdateNodepoolTaintDto, uuid *string, instanceNo *string) (*UpdateNodePoolRes, error) {
  1122  	var (
  1123  		localVarHttpMethod = strings.ToUpper("Put")
  1124  		localVarPostBody   interface{}
  1125  		localVarFileName   string
  1126  		localVarFileBytes  []byte
  1127  		successPayload     UpdateNodePoolRes
  1128  	)
  1129  
  1130  	// create path and map variables
  1131  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}/taints"
  1132  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1133  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
  1134  
  1135  	localVarHeaderParams := make(map[string]string)
  1136  	localVarQueryParams := url.Values{}
  1137  	localVarFormParams := url.Values{}
  1138  
  1139  	// to determine the Content-Type header
  1140  	localVarHttpContentTypes := []string{"application/json"}
  1141  
  1142  	// set Content-Type header
  1143  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1144  	if localVarHttpContentType != "" {
  1145  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1146  	}
  1147  
  1148  	// to determine the Accept header
  1149  	localVarHttpHeaderAccepts := []string{
  1150  		"application/json",
  1151  	}
  1152  
  1153  	// set Accept header
  1154  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1155  	if localVarHttpHeaderAccept != "" {
  1156  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1157  	}
  1158  	// body params
  1159  	localVarPostBody = body
  1160  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1161  	if v.IsValid() && v.CanAddr() {
  1162  		ptr := v.Addr().Interface().(**string)
  1163  		if *ptr != nil {
  1164  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1165  		}
  1166  	}
  1167  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1168  	if err != nil {
  1169  		return &successPayload, err
  1170  	}
  1171  
  1172  	localVarHttpResponse, err := a.client.callAPI(r)
  1173  	if err != nil || localVarHttpResponse == nil {
  1174  		return &successPayload, err
  1175  	}
  1176  	defer localVarHttpResponse.Body.Close()
  1177  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1178  
  1179  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1180  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1181  	}
  1182  
  1183  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1184  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1185  			return &successPayload, err
  1186  		}
  1187  	}
  1188  
  1189  	return &successPayload, err
  1190  }
  1191  
  1192  /* V2ApiService
  1193  @param uuid uuid
  1194  @param instanceNo instanceNo
  1195  @param k8sVersion
  1196  @param optional (nil or map[string]interface{}) with one or more of:
  1197      @param "maxSurge" (int32)
  1198      @param "maxUnavailable" (int32)
  1199  @return *UpdateNodePoolRes*/
  1200  func (a *V2ApiService) ClustersUuidNodePoolInstanceNoUpgradePatch(ctx context.Context, uuid *string, instanceNo *string, k8sVersion *string, localVarOptionals map[string]interface{}) (*UpdateNodePoolRes, error) {
  1201  	var (
  1202  		localVarHttpMethod = strings.ToUpper("Patch")
  1203  		localVarPostBody   interface{}
  1204  		localVarFileName   string
  1205  		localVarFileBytes  []byte
  1206  		successPayload     UpdateNodePoolRes
  1207  	)
  1208  
  1209  	// create path and map variables
  1210  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool/{instanceNo}/upgrade"
  1211  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1212  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
  1213  
  1214  	localVarHeaderParams := make(map[string]string)
  1215  	localVarQueryParams := url.Values{}
  1216  	localVarFormParams := url.Values{}
  1217  	if err := typeCheckParameter(localVarOptionals["maxSurge"], "*int32", "maxSurge"); err != nil {
  1218  		return &successPayload, err
  1219  	}
  1220  	if err := typeCheckParameter(localVarOptionals["maxUnavailable"], "*int32", "maxUnavailable"); err != nil {
  1221  		return &successPayload, err
  1222  	}
  1223  
  1224  	localVarQueryParams.Add("k8sVersion", parameterToString(*k8sVersion, ""))
  1225  	if localVarTempParam, localVarOk := localVarOptionals["maxSurge"].(*int32); localVarOk {
  1226  		localVarQueryParams.Add("maxSurge", parameterToString(*localVarTempParam, ""))
  1227  	}
  1228  	if localVarTempParam, localVarOk := localVarOptionals["maxUnavailable"].(*int32); localVarOk {
  1229  		localVarQueryParams.Add("maxUnavailable", parameterToString(*localVarTempParam, ""))
  1230  	}
  1231  	// to determine the Content-Type header
  1232  	localVarHttpContentTypes := []string{"application/json"}
  1233  
  1234  	// set Content-Type header
  1235  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1236  	if localVarHttpContentType != "" {
  1237  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1238  	}
  1239  
  1240  	// to determine the Accept header
  1241  	localVarHttpHeaderAccepts := []string{
  1242  		"application/json",
  1243  	}
  1244  
  1245  	// set Accept header
  1246  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1247  	if localVarHttpHeaderAccept != "" {
  1248  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1249  	}
  1250  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1251  	if err != nil {
  1252  		return &successPayload, err
  1253  	}
  1254  
  1255  	localVarHttpResponse, err := a.client.callAPI(r)
  1256  	if err != nil || localVarHttpResponse == nil {
  1257  		return &successPayload, err
  1258  	}
  1259  	defer localVarHttpResponse.Body.Close()
  1260  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1261  
  1262  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1263  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1264  	}
  1265  
  1266  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1267  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1268  			return &successPayload, err
  1269  		}
  1270  	}
  1271  
  1272  	return &successPayload, err
  1273  }
  1274  
  1275  /* V2ApiService
  1276  @param body
  1277  @param uuid uuid
  1278  @return *UpdateClusterRes*/
  1279  func (a *V2ApiService) ClustersUuidNodePoolPost(ctx context.Context, body *NodePoolCreationBody, uuid *string) (*UpdateClusterRes, error) {
  1280  	var (
  1281  		localVarHttpMethod = strings.ToUpper("Post")
  1282  		localVarPostBody   interface{}
  1283  		localVarFileName   string
  1284  		localVarFileBytes  []byte
  1285  		successPayload     UpdateClusterRes
  1286  	)
  1287  
  1288  	// create path and map variables
  1289  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/node-pool"
  1290  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1291  
  1292  	localVarHeaderParams := make(map[string]string)
  1293  	localVarQueryParams := url.Values{}
  1294  	localVarFormParams := url.Values{}
  1295  
  1296  	// to determine the Content-Type header
  1297  	localVarHttpContentTypes := []string{"application/json"}
  1298  
  1299  	// set Content-Type header
  1300  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1301  	if localVarHttpContentType != "" {
  1302  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1303  	}
  1304  
  1305  	// to determine the Accept header
  1306  	localVarHttpHeaderAccepts := []string{
  1307  		"application/json",
  1308  	}
  1309  
  1310  	// set Accept header
  1311  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1312  	if localVarHttpHeaderAccept != "" {
  1313  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1314  	}
  1315  	// body params
  1316  	localVarPostBody = body
  1317  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1318  	if err != nil {
  1319  		return &successPayload, err
  1320  	}
  1321  
  1322  	localVarHttpResponse, err := a.client.callAPI(r)
  1323  	if err != nil || localVarHttpResponse == nil {
  1324  		return &successPayload, err
  1325  	}
  1326  	defer localVarHttpResponse.Body.Close()
  1327  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1328  
  1329  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1330  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1331  	}
  1332  
  1333  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1334  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1335  			return &successPayload, err
  1336  		}
  1337  	}
  1338  
  1339  	return &successPayload, err
  1340  }
  1341  
  1342  /* V2ApiService
  1343  @param uuid uuid
  1344  @return *WorkerNodeRes*/
  1345  func (a *V2ApiService) ClustersUuidNodesGet(ctx context.Context, uuid *string) (*WorkerNodeRes, error) {
  1346  	var (
  1347  		localVarHttpMethod = strings.ToUpper("Get")
  1348  		localVarPostBody   interface{}
  1349  		localVarFileName   string
  1350  		localVarFileBytes  []byte
  1351  		successPayload     WorkerNodeRes
  1352  	)
  1353  
  1354  	// create path and map variables
  1355  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/nodes"
  1356  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1357  
  1358  	localVarHeaderParams := make(map[string]string)
  1359  	localVarQueryParams := url.Values{}
  1360  	localVarFormParams := url.Values{}
  1361  
  1362  	// to determine the Content-Type header
  1363  	localVarHttpContentTypes := []string{"application/json"}
  1364  
  1365  	// set Content-Type header
  1366  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1367  	if localVarHttpContentType != "" {
  1368  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1369  	}
  1370  
  1371  	// to determine the Accept header
  1372  	localVarHttpHeaderAccepts := []string{
  1373  		"application/json",
  1374  	}
  1375  
  1376  	// set Accept header
  1377  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1378  	if localVarHttpHeaderAccept != "" {
  1379  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1380  	}
  1381  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1382  	if err != nil {
  1383  		return &successPayload, err
  1384  	}
  1385  
  1386  	localVarHttpResponse, err := a.client.callAPI(r)
  1387  	if err != nil || localVarHttpResponse == nil {
  1388  		return &successPayload, err
  1389  	}
  1390  	defer localVarHttpResponse.Body.Close()
  1391  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1392  
  1393  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1394  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1395  	}
  1396  
  1397  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1398  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1399  			return &successPayload, err
  1400  		}
  1401  	}
  1402  
  1403  	return &successPayload, err
  1404  }
  1405  
  1406  /* V2ApiService
  1407  @param uuid uuid
  1408  @param instanceNo instanceNo
  1409  @param optional (nil or map[string]interface{}) with one or more of:
  1410      @param "nodePoolId" (string) 노드풀 인스턴스 번호
  1411  @return */
  1412  func (a *V2ApiService) ClustersUuidNodesInstanceNoDelete(ctx context.Context, uuid *string, instanceNo *string, localVarOptionals map[string]interface{}) error {
  1413  	var (
  1414  		localVarHttpMethod = strings.ToUpper("Delete")
  1415  		localVarPostBody   interface{}
  1416  		localVarFileName   string
  1417  		localVarFileBytes  []byte
  1418  	)
  1419  
  1420  	// create path and map variables
  1421  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/nodes/{instanceNo}"
  1422  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1423  	localVarPath = strings.Replace(localVarPath, "{"+"instanceNo"+"}", fmt.Sprintf("%v", *instanceNo), -1)
  1424  
  1425  	localVarHeaderParams := make(map[string]string)
  1426  	localVarQueryParams := url.Values{}
  1427  	localVarFormParams := url.Values{}
  1428  	if err := typeCheckParameter(localVarOptionals["nodePoolId"], "*string", "nodePoolId"); err != nil {
  1429  		return err
  1430  	}
  1431  
  1432  	if localVarTempParam, localVarOk := localVarOptionals["nodePoolId"].(*string); localVarOk {
  1433  		localVarQueryParams.Add("nodePoolId", parameterToString(*localVarTempParam, ""))
  1434  	}
  1435  	// to determine the Content-Type header
  1436  	localVarHttpContentTypes := []string{"application/json"}
  1437  
  1438  	// set Content-Type header
  1439  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1440  	if localVarHttpContentType != "" {
  1441  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1442  	}
  1443  
  1444  	// to determine the Accept header
  1445  	localVarHttpHeaderAccepts := []string{
  1446  		"application/json",
  1447  	}
  1448  
  1449  	// set Accept header
  1450  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1451  	if localVarHttpHeaderAccept != "" {
  1452  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1453  	}
  1454  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1455  	if err != nil {
  1456  		return err
  1457  	}
  1458  
  1459  	localVarHttpResponse, err := a.client.callAPI(r)
  1460  	if err != nil || localVarHttpResponse == nil {
  1461  		return err
  1462  	}
  1463  	defer localVarHttpResponse.Body.Close()
  1464  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1465  
  1466  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1467  		return reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1468  	}
  1469  
  1470  	return err
  1471  }
  1472  
  1473  /* V2ApiService
  1474  @param uuid uuid
  1475  @return *OidcRes*/
  1476  func (a *V2ApiService) ClustersUuidOidcGet(ctx context.Context, uuid *string) (*OidcRes, error) {
  1477  	var (
  1478  		localVarHttpMethod = strings.ToUpper("Get")
  1479  		localVarPostBody   interface{}
  1480  		localVarFileName   string
  1481  		localVarFileBytes  []byte
  1482  		successPayload     OidcRes
  1483  	)
  1484  
  1485  	// create path and map variables
  1486  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/oidc"
  1487  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1488  
  1489  	localVarHeaderParams := make(map[string]string)
  1490  	localVarQueryParams := url.Values{}
  1491  	localVarFormParams := url.Values{}
  1492  
  1493  	// to determine the Content-Type header
  1494  	localVarHttpContentTypes := []string{"application/json"}
  1495  
  1496  	// set Content-Type header
  1497  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1498  	if localVarHttpContentType != "" {
  1499  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1500  	}
  1501  
  1502  	// to determine the Accept header
  1503  	localVarHttpHeaderAccepts := []string{
  1504  		"application/json",
  1505  	}
  1506  
  1507  	// set Accept header
  1508  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1509  	if localVarHttpHeaderAccept != "" {
  1510  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1511  	}
  1512  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1513  	if err != nil {
  1514  		return &successPayload, err
  1515  	}
  1516  
  1517  	localVarHttpResponse, err := a.client.callAPI(r)
  1518  	if err != nil || localVarHttpResponse == nil {
  1519  		return &successPayload, err
  1520  	}
  1521  	defer localVarHttpResponse.Body.Close()
  1522  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1523  
  1524  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1525  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1526  	}
  1527  
  1528  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1529  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1530  			return &successPayload, err
  1531  		}
  1532  	}
  1533  
  1534  	return &successPayload, err
  1535  }
  1536  
  1537  /* V2ApiService
  1538  @param body
  1539  @param uuid uuid
  1540  @return *UpdateClusterRes*/
  1541  func (a *V2ApiService) ClustersUuidOidcPatch(ctx context.Context, body *UpdateOidcDto, uuid *string) (*UpdateClusterRes, error) {
  1542  	var (
  1543  		localVarHttpMethod = strings.ToUpper("Patch")
  1544  		localVarPostBody   interface{}
  1545  		localVarFileName   string
  1546  		localVarFileBytes  []byte
  1547  		successPayload     UpdateClusterRes
  1548  	)
  1549  
  1550  	// create path and map variables
  1551  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/oidc"
  1552  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1553  
  1554  	localVarHeaderParams := make(map[string]string)
  1555  	localVarQueryParams := url.Values{}
  1556  	localVarFormParams := url.Values{}
  1557  
  1558  	// to determine the Content-Type header
  1559  	localVarHttpContentTypes := []string{"application/json"}
  1560  
  1561  	// set Content-Type header
  1562  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1563  	if localVarHttpContentType != "" {
  1564  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1565  	}
  1566  
  1567  	// to determine the Accept header
  1568  	localVarHttpHeaderAccepts := []string{
  1569  		"application/json",
  1570  	}
  1571  
  1572  	// set Accept header
  1573  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1574  	if localVarHttpHeaderAccept != "" {
  1575  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1576  	}
  1577  	// body params
  1578  	localVarPostBody = body
  1579  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1580  	if v.IsValid() && v.CanAddr() {
  1581  		ptr := v.Addr().Interface().(**string)
  1582  		if *ptr != nil {
  1583  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1584  		}
  1585  	}
  1586  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1587  	if err != nil {
  1588  		return &successPayload, err
  1589  	}
  1590  
  1591  	localVarHttpResponse, err := a.client.callAPI(r)
  1592  	if err != nil || localVarHttpResponse == nil {
  1593  		return &successPayload, err
  1594  	}
  1595  	defer localVarHttpResponse.Body.Close()
  1596  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1597  
  1598  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1599  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1600  	}
  1601  
  1602  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1603  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1604  			return &successPayload, err
  1605  		}
  1606  	}
  1607  
  1608  	return &successPayload, err
  1609  }
  1610  
  1611  /* V2ApiService
  1612  @param body
  1613  @param uuid uuid
  1614  @return *UpdateClusterRes*/
  1615  func (a *V2ApiService) ClustersUuidReturnProtectionPatch(ctx context.Context, body *ReturnProtectionDto, uuid *string) (*UpdateClusterRes, error) {
  1616  	var (
  1617  		localVarHttpMethod = strings.ToUpper("Patch")
  1618  		localVarPostBody   interface{}
  1619  		localVarFileName   string
  1620  		localVarFileBytes  []byte
  1621  		successPayload     UpdateClusterRes
  1622  	)
  1623  
  1624  	// create path and map variables
  1625  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/return-protection"
  1626  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1627  
  1628  	localVarHeaderParams := make(map[string]string)
  1629  	localVarQueryParams := url.Values{}
  1630  	localVarFormParams := url.Values{}
  1631  
  1632  	// to determine the Content-Type header
  1633  	localVarHttpContentTypes := []string{"application/json"}
  1634  
  1635  	// set Content-Type header
  1636  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1637  	if localVarHttpContentType != "" {
  1638  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1639  	}
  1640  
  1641  	// to determine the Accept header
  1642  	localVarHttpHeaderAccepts := []string{
  1643  		"application/json",
  1644  	}
  1645  
  1646  	// set Accept header
  1647  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1648  	if localVarHttpHeaderAccept != "" {
  1649  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1650  	}
  1651  	// body params
  1652  	localVarPostBody = body
  1653  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1654  	if v.IsValid() && v.CanAddr() {
  1655  		ptr := v.Addr().Interface().(**string)
  1656  		if *ptr != nil {
  1657  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1658  		}
  1659  	}
  1660  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1661  	if err != nil {
  1662  		return &successPayload, err
  1663  	}
  1664  
  1665  	localVarHttpResponse, err := a.client.callAPI(r)
  1666  	if err != nil || localVarHttpResponse == nil {
  1667  		return &successPayload, err
  1668  	}
  1669  	defer localVarHttpResponse.Body.Close()
  1670  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1671  
  1672  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1673  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1674  	}
  1675  
  1676  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1677  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1678  			return &successPayload, err
  1679  		}
  1680  	}
  1681  
  1682  	return &successPayload, err
  1683  }
  1684  
  1685  /* V2ApiService
  1686  @param uuid uuid
  1687  @param k8sVersion
  1688  @param optional (nil or map[string]interface{}) with one or more of:
  1689      @param "maxSurge" (int32)
  1690      @param "maxUnavailable" (int32)
  1691  @return *UpdateClusterRes*/
  1692  func (a *V2ApiService) ClustersUuidUpgradePatch(ctx context.Context, uuid *string, k8sVersion *string, localVarOptionals map[string]interface{}) (*UpdateClusterRes, error) {
  1693  	var (
  1694  		localVarHttpMethod = strings.ToUpper("Patch")
  1695  		localVarPostBody   interface{}
  1696  		localVarFileName   string
  1697  		localVarFileBytes  []byte
  1698  		successPayload     UpdateClusterRes
  1699  	)
  1700  
  1701  	// create path and map variables
  1702  	localVarPath := a.client.cfg.BasePath + "/clusters/{uuid}/upgrade"
  1703  	localVarPath = strings.Replace(localVarPath, "{"+"uuid"+"}", fmt.Sprintf("%v", *uuid), -1)
  1704  
  1705  	localVarHeaderParams := make(map[string]string)
  1706  	localVarQueryParams := url.Values{}
  1707  	localVarFormParams := url.Values{}
  1708  	if err := typeCheckParameter(localVarOptionals["maxSurge"], "*int32", "maxSurge"); err != nil {
  1709  		return &successPayload, err
  1710  	}
  1711  	if err := typeCheckParameter(localVarOptionals["maxUnavailable"], "*int32", "maxUnavailable"); err != nil {
  1712  		return &successPayload, err
  1713  	}
  1714  
  1715  	localVarQueryParams.Add("k8sVersion", parameterToString(*k8sVersion, ""))
  1716  	if localVarTempParam, localVarOk := localVarOptionals["maxSurge"].(*int32); localVarOk {
  1717  		localVarQueryParams.Add("maxSurge", parameterToString(*localVarTempParam, ""))
  1718  	}
  1719  	if localVarTempParam, localVarOk := localVarOptionals["maxUnavailable"].(*int32); localVarOk {
  1720  		localVarQueryParams.Add("maxUnavailable", parameterToString(*localVarTempParam, ""))
  1721  	}
  1722  	// to determine the Content-Type header
  1723  	localVarHttpContentTypes := []string{"application/json"}
  1724  
  1725  	// set Content-Type header
  1726  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1727  	if localVarHttpContentType != "" {
  1728  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1729  	}
  1730  
  1731  	// to determine the Accept header
  1732  	localVarHttpHeaderAccepts := []string{
  1733  		"application/json",
  1734  	}
  1735  
  1736  	// set Accept header
  1737  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1738  	if localVarHttpHeaderAccept != "" {
  1739  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1740  	}
  1741  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1742  	if err != nil {
  1743  		return &successPayload, err
  1744  	}
  1745  
  1746  	localVarHttpResponse, err := a.client.callAPI(r)
  1747  	if err != nil || localVarHttpResponse == nil {
  1748  		return &successPayload, err
  1749  	}
  1750  	defer localVarHttpResponse.Body.Close()
  1751  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1752  
  1753  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1754  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1755  	}
  1756  
  1757  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1758  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1759  			return &successPayload, err
  1760  		}
  1761  	}
  1762  
  1763  	return &successPayload, err
  1764  }
  1765  
  1766  /* V2ApiService
  1767  @param optional (nil or map[string]interface{}) with one or more of:
  1768      @param "hypervisorCode" (string)
  1769  @return *OptionsRes*/
  1770  func (a *V2ApiService) OptionServerImageGet(ctx context.Context, localVarOptionals map[string]interface{}) (*OptionsRes, error) {
  1771  	var (
  1772  		localVarHttpMethod = strings.ToUpper("Get")
  1773  		localVarPostBody   interface{}
  1774  		localVarFileName   string
  1775  		localVarFileBytes  []byte
  1776  		successPayload     OptionsRes
  1777  	)
  1778  
  1779  	// create path and map variables
  1780  	localVarPath := a.client.cfg.BasePath + "/option/server-image"
  1781  
  1782  	localVarHeaderParams := make(map[string]string)
  1783  	localVarQueryParams := url.Values{}
  1784  	localVarFormParams := url.Values{}
  1785  	if err := typeCheckParameter(localVarOptionals["hypervisorCode"], "*string", "hypervisorCode"); err != nil {
  1786  		return &successPayload, err
  1787  	}
  1788  
  1789  	if localVarTempParam, localVarOk := localVarOptionals["hypervisorCode"].(*string); localVarOk {
  1790  		localVarQueryParams.Add("hypervisorCode", parameterToString(*localVarTempParam, ""))
  1791  	}
  1792  	// to determine the Content-Type header
  1793  	localVarHttpContentTypes := []string{"application/json"}
  1794  
  1795  	// set Content-Type header
  1796  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1797  	if localVarHttpContentType != "" {
  1798  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1799  	}
  1800  
  1801  	// to determine the Accept header
  1802  	localVarHttpHeaderAccepts := []string{
  1803  		"application/json",
  1804  	}
  1805  
  1806  	// set Accept header
  1807  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1808  	if localVarHttpHeaderAccept != "" {
  1809  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1810  	}
  1811  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1812  	if err != nil {
  1813  		return &successPayload, err
  1814  	}
  1815  
  1816  	localVarHttpResponse, err := a.client.callAPI(r)
  1817  	if err != nil || localVarHttpResponse == nil {
  1818  		return &successPayload, err
  1819  	}
  1820  	defer localVarHttpResponse.Body.Close()
  1821  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1822  
  1823  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1824  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1825  	}
  1826  
  1827  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1828  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1829  			return &successPayload, err
  1830  		}
  1831  	}
  1832  
  1833  	return &successPayload, err
  1834  }
  1835  
  1836  /* V2ApiService
  1837  @param softwareCode
  1838  @param optional (nil or map[string]interface{}) with one or more of:
  1839      @param "zoneCode" (string)
  1840      @param "zoneNo" (string)
  1841  @return *OptionsResForServerProduct*/
  1842  func (a *V2ApiService) OptionServerProductCodeGet(ctx context.Context, softwareCode *string, localVarOptionals map[string]interface{}) (*OptionsResForServerProduct, error) {
  1843  	var (
  1844  		localVarHttpMethod = strings.ToUpper("Get")
  1845  		localVarPostBody   interface{}
  1846  		localVarFileName   string
  1847  		localVarFileBytes  []byte
  1848  		successPayload     OptionsResForServerProduct
  1849  	)
  1850  
  1851  	// create path and map variables
  1852  	localVarPath := a.client.cfg.BasePath + "/option/server-product-code"
  1853  
  1854  	localVarHeaderParams := make(map[string]string)
  1855  	localVarQueryParams := url.Values{}
  1856  	localVarFormParams := url.Values{}
  1857  	if err := typeCheckParameter(localVarOptionals["hypervisorCode"], "*string", "hypervisorCode"); err != nil {
  1858  		return &successPayload, err
  1859  	}
  1860  	if err := typeCheckParameter(localVarOptionals["zoneCode"], "*string", "zoneCode"); err != nil {
  1861  		return &successPayload, err
  1862  	}
  1863  	if err := typeCheckParameter(localVarOptionals["zoneNo"], "*string", "zoneNo"); err != nil {
  1864  		return &successPayload, err
  1865  	}
  1866  
  1867  	if localVarTempParam, localVarOk := localVarOptionals["hypervisorCode"].(*string); localVarOk {
  1868  		localVarQueryParams.Add("hypervisorCode", parameterToString(*localVarTempParam, ""))
  1869  	}
  1870  	localVarQueryParams.Add("softwareCode", parameterToString(*softwareCode, ""))
  1871  	if localVarTempParam, localVarOk := localVarOptionals["zoneCode"].(*string); localVarOk {
  1872  		localVarQueryParams.Add("zoneCode", parameterToString(*localVarTempParam, ""))
  1873  	}
  1874  	if localVarTempParam, localVarOk := localVarOptionals["zoneNo"].(*string); localVarOk {
  1875  		localVarQueryParams.Add("zoneNo", parameterToString(*localVarTempParam, ""))
  1876  	}
  1877  	// to determine the Content-Type header
  1878  	localVarHttpContentTypes := []string{"application/json"}
  1879  
  1880  	// set Content-Type header
  1881  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1882  	if localVarHttpContentType != "" {
  1883  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1884  	}
  1885  
  1886  	// to determine the Accept header
  1887  	localVarHttpHeaderAccepts := []string{
  1888  		"application/json",
  1889  	}
  1890  
  1891  	// set Accept header
  1892  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1893  	if localVarHttpHeaderAccept != "" {
  1894  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1895  	}
  1896  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1897  	if err != nil {
  1898  		return &successPayload, err
  1899  	}
  1900  
  1901  	localVarHttpResponse, err := a.client.callAPI(r)
  1902  	if err != nil || localVarHttpResponse == nil {
  1903  		return &successPayload, err
  1904  	}
  1905  	defer localVarHttpResponse.Body.Close()
  1906  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1907  
  1908  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1909  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1910  	}
  1911  
  1912  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1913  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1914  			return &successPayload, err
  1915  		}
  1916  	}
  1917  
  1918  	return &successPayload, err
  1919  }
  1920  
  1921  /* V2ApiService
  1922  @param optional (nil or map[string]interface{}) with one or more of:
  1923      @param "from" (string)
  1924      @param "to" (string)
  1925  @return *OptionsRes*/
  1926  func (a *V2ApiService) OptionVersionGet(ctx context.Context, localVarOptionals map[string]interface{}) (*OptionsRes, error) {
  1927  	var (
  1928  		localVarHttpMethod = strings.ToUpper("Get")
  1929  		localVarPostBody   interface{}
  1930  		localVarFileName   string
  1931  		localVarFileBytes  []byte
  1932  		successPayload     OptionsRes
  1933  	)
  1934  
  1935  	// create path and map variables
  1936  	localVarPath := a.client.cfg.BasePath + "/option/version"
  1937  
  1938  	localVarHeaderParams := make(map[string]string)
  1939  	localVarQueryParams := url.Values{}
  1940  	localVarFormParams := url.Values{}
  1941  	if err := typeCheckParameter(localVarOptionals["from"], "*string", "from"); err != nil {
  1942  		return &successPayload, err
  1943  	}
  1944  	if err := typeCheckParameter(localVarOptionals["hypervisorCode"], "*string", "hypervisorCode"); err != nil {
  1945  		return &successPayload, err
  1946  	}
  1947  	if err := typeCheckParameter(localVarOptionals["to"], "*string", "to"); err != nil {
  1948  		return &successPayload, err
  1949  	}
  1950  
  1951  	if localVarTempParam, localVarOk := localVarOptionals["from"].(*string); localVarOk {
  1952  		localVarQueryParams.Add("from", parameterToString(*localVarTempParam, ""))
  1953  	}
  1954  	if localVarTempParam, localVarOk := localVarOptionals["hypervisorCode"].(*string); localVarOk {
  1955  		localVarQueryParams.Add("hypervisorCode", parameterToString(*localVarTempParam, ""))
  1956  	}
  1957  	if localVarTempParam, localVarOk := localVarOptionals["to"].(*string); localVarOk {
  1958  		localVarQueryParams.Add("to", parameterToString(*localVarTempParam, ""))
  1959  	}
  1960  	// to determine the Content-Type header
  1961  	localVarHttpContentTypes := []string{"application/json"}
  1962  
  1963  	// set Content-Type header
  1964  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1965  	if localVarHttpContentType != "" {
  1966  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1967  	}
  1968  
  1969  	// to determine the Accept header
  1970  	localVarHttpHeaderAccepts := []string{
  1971  		"application/json",
  1972  	}
  1973  
  1974  	// set Accept header
  1975  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1976  	if localVarHttpHeaderAccept != "" {
  1977  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1978  	}
  1979  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1980  	if err != nil {
  1981  		return &successPayload, err
  1982  	}
  1983  
  1984  	localVarHttpResponse, err := a.client.callAPI(r)
  1985  	if err != nil || localVarHttpResponse == nil {
  1986  		return &successPayload, err
  1987  	}
  1988  	defer localVarHttpResponse.Body.Close()
  1989  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1990  
  1991  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  1992  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1993  	}
  1994  
  1995  	if !strings.Contains(string(bodyBytes), `{"error"`) && (strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`)) {
  1996  		if err = json.Unmarshal(bodyBytes, &successPayload); err != nil {
  1997  			return &successPayload, err
  1998  		}
  1999  	}
  2000  
  2001  	return &successPayload, err
  2002  }
  2003  
  2004  /* V2ApiService
  2005  @return */
  2006  func (a *V2ApiService) RootGet(ctx context.Context) error {
  2007  	var (
  2008  		localVarHttpMethod = strings.ToUpper("Get")
  2009  		localVarPostBody   interface{}
  2010  		localVarFileName   string
  2011  		localVarFileBytes  []byte
  2012  	)
  2013  
  2014  	// create path and map variables
  2015  	localVarPath := a.client.cfg.BasePath + "/"
  2016  
  2017  	localVarHeaderParams := make(map[string]string)
  2018  	localVarQueryParams := url.Values{}
  2019  	localVarFormParams := url.Values{}
  2020  
  2021  	// to determine the Content-Type header
  2022  	localVarHttpContentTypes := []string{"application/json"}
  2023  
  2024  	// set Content-Type header
  2025  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2026  	if localVarHttpContentType != "" {
  2027  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2028  	}
  2029  
  2030  	// to determine the Accept header
  2031  	localVarHttpHeaderAccepts := []string{
  2032  		"application/json",
  2033  	}
  2034  
  2035  	// set Accept header
  2036  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2037  	if localVarHttpHeaderAccept != "" {
  2038  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2039  	}
  2040  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2041  	if err != nil {
  2042  		return err
  2043  	}
  2044  
  2045  	localVarHttpResponse, err := a.client.callAPI(r)
  2046  	if err != nil || localVarHttpResponse == nil {
  2047  		return err
  2048  	}
  2049  	defer localVarHttpResponse.Body.Close()
  2050  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  2051  
  2052  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !(strings.HasPrefix(string(bodyBytes), `{`) || strings.HasPrefix(string(bodyBytes), `[`))) && localVarHttpResponse.StatusCode != 204 {
  2053  		return reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  2054  	}
  2055  
  2056  	return err
  2057  }