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

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