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

     1  /*
     2   * vnas
     3   *
     4   * VPC NAS 관련 API<br/>https://ncloud.apigw.ntruss.com/vnas/v2
     5   *
     6   * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
     7   */
     8  
     9  package vnas
    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   @param addNasVolumeAccessControlRequest addNasVolumeAccessControlRequest
    33   @return *AddNasVolumeAccessControlResponse*/
    34  func (a *V2ApiService) AddNasVolumeAccessControl(addNasVolumeAccessControlRequest *AddNasVolumeAccessControlRequest) (*AddNasVolumeAccessControlResponse, error) {
    35  	var (
    36  		localVarHttpMethod = strings.ToUpper("Post")
    37  		localVarPostBody interface{}
    38  		localVarFileName string
    39  		localVarFileBytes []byte
    40  	 	successPayload  AddNasVolumeAccessControlResponse
    41  	)
    42  
    43  	// create path and map variables
    44  	localVarPath := a.client.cfg.BasePath + "/addNasVolumeAccessControl"
    45  
    46  	localVarHeaderParams := make(map[string]string)
    47  	localVarQueryParams := url.Values{}
    48  	localVarFormParams := url.Values{}
    49  
    50  
    51  	// to determine the Content-Type header
    52  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
    53  
    54  	// set Content-Type header
    55  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    56  	if localVarHttpContentType != "" {
    57  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    58  	}
    59  
    60  	// to determine the Accept header
    61  	localVarHttpHeaderAccepts := []string{
    62  		}
    63  
    64  	// set Accept header
    65  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    66  	if localVarHttpHeaderAccept != "" {
    67  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    68  	}
    69  	// body params
    70  	localVarPostBody = addNasVolumeAccessControlRequest
    71  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
    72  	if v.IsValid() && v.CanAddr() {
    73  		ptr := v.Addr().Interface().(**string)
    74  		if *ptr != nil {
    75  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
    76  		}
    77  	}
    78  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    79  	if err != nil {
    80  		return &successPayload, err
    81  	}
    82  
    83  	localVarHttpResponse, err := a.client.callAPI(r)
    84  	if err != nil || localVarHttpResponse == nil {
    85  		return &successPayload, err
    86  	}
    87  	defer localVarHttpResponse.Body.Close()
    88  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
    89  
    90  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
    91  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
    92  	}
    93  
    94  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
    95  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
    96  			return &successPayload, err
    97  		}
    98  	}
    99  
   100  
   101  	return &successPayload, err
   102  }
   103  
   104  /* V2ApiService 
   105   @param changeNasVolumeSizeRequest changeNasVolumeSizeRequest
   106   @return *ChangeNasVolumeSizeResponse*/
   107  func (a *V2ApiService) ChangeNasVolumeSize(changeNasVolumeSizeRequest *ChangeNasVolumeSizeRequest) (*ChangeNasVolumeSizeResponse, error) {
   108  	var (
   109  		localVarHttpMethod = strings.ToUpper("Post")
   110  		localVarPostBody interface{}
   111  		localVarFileName string
   112  		localVarFileBytes []byte
   113  	 	successPayload  ChangeNasVolumeSizeResponse
   114  	)
   115  
   116  	// create path and map variables
   117  	localVarPath := a.client.cfg.BasePath + "/changeNasVolumeSize"
   118  
   119  	localVarHeaderParams := make(map[string]string)
   120  	localVarQueryParams := url.Values{}
   121  	localVarFormParams := url.Values{}
   122  
   123  
   124  	// to determine the Content-Type header
   125  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   126  
   127  	// set Content-Type header
   128  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   129  	if localVarHttpContentType != "" {
   130  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   131  	}
   132  
   133  	// to determine the Accept header
   134  	localVarHttpHeaderAccepts := []string{
   135  		}
   136  
   137  	// set Accept header
   138  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   139  	if localVarHttpHeaderAccept != "" {
   140  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   141  	}
   142  	// body params
   143  	localVarPostBody = changeNasVolumeSizeRequest
   144  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   145  	if v.IsValid() && v.CanAddr() {
   146  		ptr := v.Addr().Interface().(**string)
   147  		if *ptr != nil {
   148  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   149  		}
   150  	}
   151  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   152  	if err != nil {
   153  		return &successPayload, err
   154  	}
   155  
   156  	localVarHttpResponse, err := a.client.callAPI(r)
   157  	if err != nil || localVarHttpResponse == nil {
   158  		return &successPayload, err
   159  	}
   160  	defer localVarHttpResponse.Body.Close()
   161  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   162  
   163  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   164  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   165  	}
   166  
   167  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   168  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   169  			return &successPayload, err
   170  		}
   171  	}
   172  
   173  
   174  	return &successPayload, err
   175  }
   176  
   177  /* V2ApiService 
   178   @param changeNasVolumeSnapshotConfigurationRequest changeNasVolumeSnapshotConfigurationRequest
   179   @return *ChangeNasVolumeSnapshotConfigurationResponse*/
   180  func (a *V2ApiService) ChangeNasVolumeSnapshotConfiguration(changeNasVolumeSnapshotConfigurationRequest *ChangeNasVolumeSnapshotConfigurationRequest) (*ChangeNasVolumeSnapshotConfigurationResponse, error) {
   181  	var (
   182  		localVarHttpMethod = strings.ToUpper("Post")
   183  		localVarPostBody interface{}
   184  		localVarFileName string
   185  		localVarFileBytes []byte
   186  	 	successPayload  ChangeNasVolumeSnapshotConfigurationResponse
   187  	)
   188  
   189  	// create path and map variables
   190  	localVarPath := a.client.cfg.BasePath + "/changeNasVolumeSnapshotConfiguration"
   191  
   192  	localVarHeaderParams := make(map[string]string)
   193  	localVarQueryParams := url.Values{}
   194  	localVarFormParams := url.Values{}
   195  
   196  
   197  	// to determine the Content-Type header
   198  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   199  
   200  	// set Content-Type header
   201  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   202  	if localVarHttpContentType != "" {
   203  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   204  	}
   205  
   206  	// to determine the Accept header
   207  	localVarHttpHeaderAccepts := []string{
   208  		}
   209  
   210  	// set Accept header
   211  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   212  	if localVarHttpHeaderAccept != "" {
   213  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   214  	}
   215  	// body params
   216  	localVarPostBody = changeNasVolumeSnapshotConfigurationRequest
   217  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   218  	if v.IsValid() && v.CanAddr() {
   219  		ptr := v.Addr().Interface().(**string)
   220  		if *ptr != nil {
   221  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   222  		}
   223  	}
   224  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   225  	if err != nil {
   226  		return &successPayload, err
   227  	}
   228  
   229  	localVarHttpResponse, err := a.client.callAPI(r)
   230  	if err != nil || localVarHttpResponse == nil {
   231  		return &successPayload, err
   232  	}
   233  	defer localVarHttpResponse.Body.Close()
   234  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   235  
   236  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   237  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   238  	}
   239  
   240  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   241  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   242  			return &successPayload, err
   243  		}
   244  	}
   245  
   246  
   247  	return &successPayload, err
   248  }
   249  
   250  /* V2ApiService 
   251   @param createNasVolumeInstanceRequest createNasVolumeInstanceRequest
   252   @return *CreateNasVolumeInstanceResponse*/
   253  func (a *V2ApiService) CreateNasVolumeInstance(createNasVolumeInstanceRequest *CreateNasVolumeInstanceRequest) (*CreateNasVolumeInstanceResponse, error) {
   254  	var (
   255  		localVarHttpMethod = strings.ToUpper("Post")
   256  		localVarPostBody interface{}
   257  		localVarFileName string
   258  		localVarFileBytes []byte
   259  	 	successPayload  CreateNasVolumeInstanceResponse
   260  	)
   261  
   262  	// create path and map variables
   263  	localVarPath := a.client.cfg.BasePath + "/createNasVolumeInstance"
   264  
   265  	localVarHeaderParams := make(map[string]string)
   266  	localVarQueryParams := url.Values{}
   267  	localVarFormParams := url.Values{}
   268  
   269  
   270  	// to determine the Content-Type header
   271  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   272  
   273  	// set Content-Type header
   274  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   275  	if localVarHttpContentType != "" {
   276  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   277  	}
   278  
   279  	// to determine the Accept header
   280  	localVarHttpHeaderAccepts := []string{
   281  		}
   282  
   283  	// set Accept header
   284  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   285  	if localVarHttpHeaderAccept != "" {
   286  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   287  	}
   288  	// body params
   289  	localVarPostBody = createNasVolumeInstanceRequest
   290  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   291  	if v.IsValid() && v.CanAddr() {
   292  		ptr := v.Addr().Interface().(**string)
   293  		if *ptr != nil {
   294  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   295  		}
   296  	}
   297  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   298  	if err != nil {
   299  		return &successPayload, err
   300  	}
   301  
   302  	localVarHttpResponse, err := a.client.callAPI(r)
   303  	if err != nil || localVarHttpResponse == nil {
   304  		return &successPayload, err
   305  	}
   306  	defer localVarHttpResponse.Body.Close()
   307  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   308  
   309  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   310  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   311  	}
   312  
   313  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   314  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   315  			return &successPayload, err
   316  		}
   317  	}
   318  
   319  
   320  	return &successPayload, err
   321  }
   322  
   323  /* V2ApiService 
   324   @param createNasVolumeSnapshotRequest createNasVolumeSnapshotRequest
   325   @return *CreateNasVolumeSnapshotResponse*/
   326  func (a *V2ApiService) CreateNasVolumeSnapshot(createNasVolumeSnapshotRequest *CreateNasVolumeSnapshotRequest) (*CreateNasVolumeSnapshotResponse, error) {
   327  	var (
   328  		localVarHttpMethod = strings.ToUpper("Post")
   329  		localVarPostBody interface{}
   330  		localVarFileName string
   331  		localVarFileBytes []byte
   332  	 	successPayload  CreateNasVolumeSnapshotResponse
   333  	)
   334  
   335  	// create path and map variables
   336  	localVarPath := a.client.cfg.BasePath + "/createNasVolumeSnapshot"
   337  
   338  	localVarHeaderParams := make(map[string]string)
   339  	localVarQueryParams := url.Values{}
   340  	localVarFormParams := url.Values{}
   341  
   342  
   343  	// to determine the Content-Type header
   344  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   345  
   346  	// set Content-Type header
   347  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   348  	if localVarHttpContentType != "" {
   349  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   350  	}
   351  
   352  	// to determine the Accept header
   353  	localVarHttpHeaderAccepts := []string{
   354  		}
   355  
   356  	// set Accept header
   357  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   358  	if localVarHttpHeaderAccept != "" {
   359  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   360  	}
   361  	// body params
   362  	localVarPostBody = createNasVolumeSnapshotRequest
   363  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   364  	if v.IsValid() && v.CanAddr() {
   365  		ptr := v.Addr().Interface().(**string)
   366  		if *ptr != nil {
   367  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   368  		}
   369  	}
   370  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   371  	if err != nil {
   372  		return &successPayload, err
   373  	}
   374  
   375  	localVarHttpResponse, err := a.client.callAPI(r)
   376  	if err != nil || localVarHttpResponse == nil {
   377  		return &successPayload, err
   378  	}
   379  	defer localVarHttpResponse.Body.Close()
   380  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   381  
   382  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   383  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   384  	}
   385  
   386  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   387  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   388  			return &successPayload, err
   389  		}
   390  	}
   391  
   392  
   393  	return &successPayload, err
   394  }
   395  
   396  /* V2ApiService 
   397   @param deleteNasVolumeInstancesRequest deleteNasVolumeInstancesRequest
   398   @return *DeleteNasVolumeInstancesResponse*/
   399  func (a *V2ApiService) DeleteNasVolumeInstances(deleteNasVolumeInstancesRequest *DeleteNasVolumeInstancesRequest) (*DeleteNasVolumeInstancesResponse, error) {
   400  	var (
   401  		localVarHttpMethod = strings.ToUpper("Post")
   402  		localVarPostBody interface{}
   403  		localVarFileName string
   404  		localVarFileBytes []byte
   405  	 	successPayload  DeleteNasVolumeInstancesResponse
   406  	)
   407  
   408  	// create path and map variables
   409  	localVarPath := a.client.cfg.BasePath + "/deleteNasVolumeInstances"
   410  
   411  	localVarHeaderParams := make(map[string]string)
   412  	localVarQueryParams := url.Values{}
   413  	localVarFormParams := url.Values{}
   414  
   415  
   416  	// to determine the Content-Type header
   417  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   418  
   419  	// set Content-Type header
   420  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   421  	if localVarHttpContentType != "" {
   422  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   423  	}
   424  
   425  	// to determine the Accept header
   426  	localVarHttpHeaderAccepts := []string{
   427  		}
   428  
   429  	// set Accept header
   430  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   431  	if localVarHttpHeaderAccept != "" {
   432  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   433  	}
   434  	// body params
   435  	localVarPostBody = deleteNasVolumeInstancesRequest
   436  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   437  	if v.IsValid() && v.CanAddr() {
   438  		ptr := v.Addr().Interface().(**string)
   439  		if *ptr != nil {
   440  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   441  		}
   442  	}
   443  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   444  	if err != nil {
   445  		return &successPayload, err
   446  	}
   447  
   448  	localVarHttpResponse, err := a.client.callAPI(r)
   449  	if err != nil || localVarHttpResponse == nil {
   450  		return &successPayload, err
   451  	}
   452  	defer localVarHttpResponse.Body.Close()
   453  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   454  
   455  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   456  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   457  	}
   458  
   459  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   460  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   461  			return &successPayload, err
   462  		}
   463  	}
   464  
   465  
   466  	return &successPayload, err
   467  }
   468  
   469  /* V2ApiService 
   470   @param deleteNasVolumeSnapshotRequest deleteNasVolumeSnapshotRequest
   471   @return *DeleteNasVolumeSnapshotResponse*/
   472  func (a *V2ApiService) DeleteNasVolumeSnapshot(deleteNasVolumeSnapshotRequest *DeleteNasVolumeSnapshotRequest) (*DeleteNasVolumeSnapshotResponse, error) {
   473  	var (
   474  		localVarHttpMethod = strings.ToUpper("Post")
   475  		localVarPostBody interface{}
   476  		localVarFileName string
   477  		localVarFileBytes []byte
   478  	 	successPayload  DeleteNasVolumeSnapshotResponse
   479  	)
   480  
   481  	// create path and map variables
   482  	localVarPath := a.client.cfg.BasePath + "/deleteNasVolumeSnapshot"
   483  
   484  	localVarHeaderParams := make(map[string]string)
   485  	localVarQueryParams := url.Values{}
   486  	localVarFormParams := url.Values{}
   487  
   488  
   489  	// to determine the Content-Type header
   490  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   491  
   492  	// set Content-Type header
   493  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   494  	if localVarHttpContentType != "" {
   495  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   496  	}
   497  
   498  	// to determine the Accept header
   499  	localVarHttpHeaderAccepts := []string{
   500  		}
   501  
   502  	// set Accept header
   503  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   504  	if localVarHttpHeaderAccept != "" {
   505  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   506  	}
   507  	// body params
   508  	localVarPostBody = deleteNasVolumeSnapshotRequest
   509  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   510  	if v.IsValid() && v.CanAddr() {
   511  		ptr := v.Addr().Interface().(**string)
   512  		if *ptr != nil {
   513  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   514  		}
   515  	}
   516  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   517  	if err != nil {
   518  		return &successPayload, err
   519  	}
   520  
   521  	localVarHttpResponse, err := a.client.callAPI(r)
   522  	if err != nil || localVarHttpResponse == nil {
   523  		return &successPayload, err
   524  	}
   525  	defer localVarHttpResponse.Body.Close()
   526  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   527  
   528  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   529  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   530  	}
   531  
   532  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   533  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   534  			return &successPayload, err
   535  		}
   536  	}
   537  
   538  
   539  	return &successPayload, err
   540  }
   541  
   542  /* V2ApiService 
   543   @param getNasVolumeAccessControlRuleListRequest getNasVolumeAccessControlRuleListRequest
   544   @return *GetNasVolumeAccessControlRuleListResponse*/
   545  func (a *V2ApiService) GetNasVolumeAccessControlRuleList(getNasVolumeAccessControlRuleListRequest *GetNasVolumeAccessControlRuleListRequest) (*GetNasVolumeAccessControlRuleListResponse, error) {
   546  	var (
   547  		localVarHttpMethod = strings.ToUpper("Post")
   548  		localVarPostBody interface{}
   549  		localVarFileName string
   550  		localVarFileBytes []byte
   551  	 	successPayload  GetNasVolumeAccessControlRuleListResponse
   552  	)
   553  
   554  	// create path and map variables
   555  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeAccessControlRuleList"
   556  
   557  	localVarHeaderParams := make(map[string]string)
   558  	localVarQueryParams := url.Values{}
   559  	localVarFormParams := url.Values{}
   560  
   561  
   562  	// to determine the Content-Type header
   563  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   564  
   565  	// set Content-Type header
   566  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   567  	if localVarHttpContentType != "" {
   568  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   569  	}
   570  
   571  	// to determine the Accept header
   572  	localVarHttpHeaderAccepts := []string{
   573  		}
   574  
   575  	// set Accept header
   576  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   577  	if localVarHttpHeaderAccept != "" {
   578  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   579  	}
   580  	// body params
   581  	localVarPostBody = getNasVolumeAccessControlRuleListRequest
   582  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   583  	if v.IsValid() && v.CanAddr() {
   584  		ptr := v.Addr().Interface().(**string)
   585  		if *ptr != nil {
   586  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   587  		}
   588  	}
   589  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   590  	if err != nil {
   591  		return &successPayload, err
   592  	}
   593  
   594  	localVarHttpResponse, err := a.client.callAPI(r)
   595  	if err != nil || localVarHttpResponse == nil {
   596  		return &successPayload, err
   597  	}
   598  	defer localVarHttpResponse.Body.Close()
   599  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   600  
   601  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   602  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   603  	}
   604  
   605  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   606  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   607  			return &successPayload, err
   608  		}
   609  	}
   610  
   611  
   612  	return &successPayload, err
   613  }
   614  
   615  /* V2ApiService 
   616   @param getNasVolumeInstanceDetailRequest getNasVolumeInstanceDetailRequest
   617   @return *GetNasVolumeInstanceDetailResponse*/
   618  func (a *V2ApiService) GetNasVolumeInstanceDetail(getNasVolumeInstanceDetailRequest *GetNasVolumeInstanceDetailRequest) (*GetNasVolumeInstanceDetailResponse, error) {
   619  	var (
   620  		localVarHttpMethod = strings.ToUpper("Post")
   621  		localVarPostBody interface{}
   622  		localVarFileName string
   623  		localVarFileBytes []byte
   624  	 	successPayload  GetNasVolumeInstanceDetailResponse
   625  	)
   626  
   627  	// create path and map variables
   628  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeInstanceDetail"
   629  
   630  	localVarHeaderParams := make(map[string]string)
   631  	localVarQueryParams := url.Values{}
   632  	localVarFormParams := url.Values{}
   633  
   634  
   635  	// to determine the Content-Type header
   636  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   637  
   638  	// set Content-Type header
   639  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   640  	if localVarHttpContentType != "" {
   641  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   642  	}
   643  
   644  	// to determine the Accept header
   645  	localVarHttpHeaderAccepts := []string{
   646  		}
   647  
   648  	// set Accept header
   649  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   650  	if localVarHttpHeaderAccept != "" {
   651  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   652  	}
   653  	// body params
   654  	localVarPostBody = getNasVolumeInstanceDetailRequest
   655  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   656  	if v.IsValid() && v.CanAddr() {
   657  		ptr := v.Addr().Interface().(**string)
   658  		if *ptr != nil {
   659  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   660  		}
   661  	}
   662  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   663  	if err != nil {
   664  		return &successPayload, err
   665  	}
   666  
   667  	localVarHttpResponse, err := a.client.callAPI(r)
   668  	if err != nil || localVarHttpResponse == nil {
   669  		return &successPayload, err
   670  	}
   671  	defer localVarHttpResponse.Body.Close()
   672  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   673  
   674  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   675  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   676  	}
   677  
   678  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   679  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   680  			return &successPayload, err
   681  		}
   682  	}
   683  
   684  
   685  	return &successPayload, err
   686  }
   687  
   688  /* V2ApiService 
   689   @param getNasVolumeInstanceListRequest getNasVolumeInstanceListRequest
   690   @return *GetNasVolumeInstanceListResponse*/
   691  func (a *V2ApiService) GetNasVolumeInstanceList(getNasVolumeInstanceListRequest *GetNasVolumeInstanceListRequest) (*GetNasVolumeInstanceListResponse, error) {
   692  	var (
   693  		localVarHttpMethod = strings.ToUpper("Post")
   694  		localVarPostBody interface{}
   695  		localVarFileName string
   696  		localVarFileBytes []byte
   697  	 	successPayload  GetNasVolumeInstanceListResponse
   698  	)
   699  
   700  	// create path and map variables
   701  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeInstanceList"
   702  
   703  	localVarHeaderParams := make(map[string]string)
   704  	localVarQueryParams := url.Values{}
   705  	localVarFormParams := url.Values{}
   706  
   707  
   708  	// to determine the Content-Type header
   709  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   710  
   711  	// set Content-Type header
   712  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   713  	if localVarHttpContentType != "" {
   714  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   715  	}
   716  
   717  	// to determine the Accept header
   718  	localVarHttpHeaderAccepts := []string{
   719  		}
   720  
   721  	// set Accept header
   722  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   723  	if localVarHttpHeaderAccept != "" {
   724  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   725  	}
   726  	// body params
   727  	localVarPostBody = getNasVolumeInstanceListRequest
   728  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   729  	if v.IsValid() && v.CanAddr() {
   730  		ptr := v.Addr().Interface().(**string)
   731  		if *ptr != nil {
   732  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   733  		}
   734  	}
   735  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   736  	if err != nil {
   737  		return &successPayload, err
   738  	}
   739  
   740  	localVarHttpResponse, err := a.client.callAPI(r)
   741  	if err != nil || localVarHttpResponse == nil {
   742  		return &successPayload, err
   743  	}
   744  	defer localVarHttpResponse.Body.Close()
   745  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   746  
   747  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   748  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   749  	}
   750  
   751  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   752  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   753  			return &successPayload, err
   754  		}
   755  	}
   756  
   757  
   758  	return &successPayload, err
   759  }
   760  
   761  /* V2ApiService 
   762   @param getNasVolumeInstanceRatingListRequest getNasVolumeInstanceRatingListRequest
   763   @return *GetNasVolumeInstanceRatingListResponse*/
   764  func (a *V2ApiService) GetNasVolumeInstanceRatingList(getNasVolumeInstanceRatingListRequest *GetNasVolumeInstanceRatingListRequest) (*GetNasVolumeInstanceRatingListResponse, error) {
   765  	var (
   766  		localVarHttpMethod = strings.ToUpper("Post")
   767  		localVarPostBody interface{}
   768  		localVarFileName string
   769  		localVarFileBytes []byte
   770  	 	successPayload  GetNasVolumeInstanceRatingListResponse
   771  	)
   772  
   773  	// create path and map variables
   774  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeInstanceRatingList"
   775  
   776  	localVarHeaderParams := make(map[string]string)
   777  	localVarQueryParams := url.Values{}
   778  	localVarFormParams := url.Values{}
   779  
   780  
   781  	// to determine the Content-Type header
   782  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   783  
   784  	// set Content-Type header
   785  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   786  	if localVarHttpContentType != "" {
   787  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   788  	}
   789  
   790  	// to determine the Accept header
   791  	localVarHttpHeaderAccepts := []string{
   792  		}
   793  
   794  	// set Accept header
   795  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   796  	if localVarHttpHeaderAccept != "" {
   797  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   798  	}
   799  	// body params
   800  	localVarPostBody = getNasVolumeInstanceRatingListRequest
   801  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   802  	if v.IsValid() && v.CanAddr() {
   803  		ptr := v.Addr().Interface().(**string)
   804  		if *ptr != nil {
   805  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   806  		}
   807  	}
   808  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   809  	if err != nil {
   810  		return &successPayload, err
   811  	}
   812  
   813  	localVarHttpResponse, err := a.client.callAPI(r)
   814  	if err != nil || localVarHttpResponse == nil {
   815  		return &successPayload, err
   816  	}
   817  	defer localVarHttpResponse.Body.Close()
   818  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   819  
   820  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   821  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   822  	}
   823  
   824  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   825  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   826  			return &successPayload, err
   827  		}
   828  	}
   829  
   830  
   831  	return &successPayload, err
   832  }
   833  
   834  /* V2ApiService 
   835   @param getNasVolumeSnapshotConfigurationHistoryListRequest getNasVolumeSnapshotConfigurationHistoryListRequest
   836   @return *GetNasVolumeSnapshotConfigurationHistoryListResponse*/
   837  func (a *V2ApiService) GetNasVolumeSnapshotConfigurationHistoryList(getNasVolumeSnapshotConfigurationHistoryListRequest *GetNasVolumeSnapshotConfigurationHistoryListRequest) (*GetNasVolumeSnapshotConfigurationHistoryListResponse, error) {
   838  	var (
   839  		localVarHttpMethod = strings.ToUpper("Post")
   840  		localVarPostBody interface{}
   841  		localVarFileName string
   842  		localVarFileBytes []byte
   843  	 	successPayload  GetNasVolumeSnapshotConfigurationHistoryListResponse
   844  	)
   845  
   846  	// create path and map variables
   847  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeSnapshotConfigurationHistoryList"
   848  
   849  	localVarHeaderParams := make(map[string]string)
   850  	localVarQueryParams := url.Values{}
   851  	localVarFormParams := url.Values{}
   852  
   853  
   854  	// to determine the Content-Type header
   855  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   856  
   857  	// set Content-Type header
   858  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   859  	if localVarHttpContentType != "" {
   860  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   861  	}
   862  
   863  	// to determine the Accept header
   864  	localVarHttpHeaderAccepts := []string{
   865  		}
   866  
   867  	// set Accept header
   868  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   869  	if localVarHttpHeaderAccept != "" {
   870  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   871  	}
   872  	// body params
   873  	localVarPostBody = getNasVolumeSnapshotConfigurationHistoryListRequest
   874  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   875  	if v.IsValid() && v.CanAddr() {
   876  		ptr := v.Addr().Interface().(**string)
   877  		if *ptr != nil {
   878  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   879  		}
   880  	}
   881  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   882  	if err != nil {
   883  		return &successPayload, err
   884  	}
   885  
   886  	localVarHttpResponse, err := a.client.callAPI(r)
   887  	if err != nil || localVarHttpResponse == nil {
   888  		return &successPayload, err
   889  	}
   890  	defer localVarHttpResponse.Body.Close()
   891  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   892  
   893  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   894  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   895  	}
   896  
   897  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   898  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   899  			return &successPayload, err
   900  		}
   901  	}
   902  
   903  
   904  	return &successPayload, err
   905  }
   906  
   907  /* V2ApiService 
   908   @param getNasVolumeSnapshotListRequest getNasVolumeSnapshotListRequest
   909   @return *GetNasVolumeSnapshotListResponse*/
   910  func (a *V2ApiService) GetNasVolumeSnapshotList(getNasVolumeSnapshotListRequest *GetNasVolumeSnapshotListRequest) (*GetNasVolumeSnapshotListResponse, error) {
   911  	var (
   912  		localVarHttpMethod = strings.ToUpper("Post")
   913  		localVarPostBody interface{}
   914  		localVarFileName string
   915  		localVarFileBytes []byte
   916  	 	successPayload  GetNasVolumeSnapshotListResponse
   917  	)
   918  
   919  	// create path and map variables
   920  	localVarPath := a.client.cfg.BasePath + "/getNasVolumeSnapshotList"
   921  
   922  	localVarHeaderParams := make(map[string]string)
   923  	localVarQueryParams := url.Values{}
   924  	localVarFormParams := url.Values{}
   925  
   926  
   927  	// to determine the Content-Type header
   928  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
   929  
   930  	// set Content-Type header
   931  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   932  	if localVarHttpContentType != "" {
   933  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   934  	}
   935  
   936  	// to determine the Accept header
   937  	localVarHttpHeaderAccepts := []string{
   938  		}
   939  
   940  	// set Accept header
   941  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   942  	if localVarHttpHeaderAccept != "" {
   943  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   944  	}
   945  	// body params
   946  	localVarPostBody = getNasVolumeSnapshotListRequest
   947  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
   948  	if v.IsValid() && v.CanAddr() {
   949  		ptr := v.Addr().Interface().(**string)
   950  		if *ptr != nil {
   951  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
   952  		}
   953  	}
   954  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   955  	if err != nil {
   956  		return &successPayload, err
   957  	}
   958  
   959  	localVarHttpResponse, err := a.client.callAPI(r)
   960  	if err != nil || localVarHttpResponse == nil {
   961  		return &successPayload, err
   962  	}
   963  	defer localVarHttpResponse.Body.Close()
   964  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
   965  
   966  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
   967  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
   968  	}
   969  
   970  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
   971  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
   972  			return &successPayload, err
   973  		}
   974  	}
   975  
   976  
   977  	return &successPayload, err
   978  }
   979  
   980  /* V2ApiService 
   981   @param removeNasVolumeAccessControlRequest removeNasVolumeAccessControlRequest
   982   @return *RemoveNasVolumeAccessControlResponse*/
   983  func (a *V2ApiService) RemoveNasVolumeAccessControl(removeNasVolumeAccessControlRequest *RemoveNasVolumeAccessControlRequest) (*RemoveNasVolumeAccessControlResponse, error) {
   984  	var (
   985  		localVarHttpMethod = strings.ToUpper("Post")
   986  		localVarPostBody interface{}
   987  		localVarFileName string
   988  		localVarFileBytes []byte
   989  	 	successPayload  RemoveNasVolumeAccessControlResponse
   990  	)
   991  
   992  	// create path and map variables
   993  	localVarPath := a.client.cfg.BasePath + "/removeNasVolumeAccessControl"
   994  
   995  	localVarHeaderParams := make(map[string]string)
   996  	localVarQueryParams := url.Values{}
   997  	localVarFormParams := url.Values{}
   998  
   999  
  1000  	// to determine the Content-Type header
  1001  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
  1002  
  1003  	// set Content-Type header
  1004  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1005  	if localVarHttpContentType != "" {
  1006  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1007  	}
  1008  
  1009  	// to determine the Accept header
  1010  	localVarHttpHeaderAccepts := []string{
  1011  		}
  1012  
  1013  	// set Accept header
  1014  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1015  	if localVarHttpHeaderAccept != "" {
  1016  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1017  	}
  1018  	// body params
  1019  	localVarPostBody = removeNasVolumeAccessControlRequest
  1020  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1021  	if v.IsValid() && v.CanAddr() {
  1022  		ptr := v.Addr().Interface().(**string)
  1023  		if *ptr != nil {
  1024  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1025  		}
  1026  	}
  1027  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1028  	if err != nil {
  1029  		return &successPayload, err
  1030  	}
  1031  
  1032  	localVarHttpResponse, err := a.client.callAPI(r)
  1033  	if err != nil || localVarHttpResponse == nil {
  1034  		return &successPayload, err
  1035  	}
  1036  	defer localVarHttpResponse.Body.Close()
  1037  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1038  
  1039  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
  1040  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1041  	}
  1042  
  1043  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
  1044  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
  1045  			return &successPayload, err
  1046  		}
  1047  	}
  1048  
  1049  
  1050  	return &successPayload, err
  1051  }
  1052  
  1053  /* V2ApiService 
  1054   @param restoreNasVolumeWithSnapshotRequest restoreNasVolumeWithSnapshotRequest
  1055   @return *RestoreNasVolumeWithSnapshotResponse*/
  1056  func (a *V2ApiService) RestoreNasVolumeWithSnapshot(restoreNasVolumeWithSnapshotRequest *RestoreNasVolumeWithSnapshotRequest) (*RestoreNasVolumeWithSnapshotResponse, error) {
  1057  	var (
  1058  		localVarHttpMethod = strings.ToUpper("Post")
  1059  		localVarPostBody interface{}
  1060  		localVarFileName string
  1061  		localVarFileBytes []byte
  1062  	 	successPayload  RestoreNasVolumeWithSnapshotResponse
  1063  	)
  1064  
  1065  	// create path and map variables
  1066  	localVarPath := a.client.cfg.BasePath + "/restoreNasVolumeWithSnapshot"
  1067  
  1068  	localVarHeaderParams := make(map[string]string)
  1069  	localVarQueryParams := url.Values{}
  1070  	localVarFormParams := url.Values{}
  1071  
  1072  
  1073  	// to determine the Content-Type header
  1074  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
  1075  
  1076  	// set Content-Type header
  1077  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1078  	if localVarHttpContentType != "" {
  1079  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1080  	}
  1081  
  1082  	// to determine the Accept header
  1083  	localVarHttpHeaderAccepts := []string{
  1084  		}
  1085  
  1086  	// set Accept header
  1087  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1088  	if localVarHttpHeaderAccept != "" {
  1089  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1090  	}
  1091  	// body params
  1092  	localVarPostBody = restoreNasVolumeWithSnapshotRequest
  1093  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1094  	if v.IsValid() && v.CanAddr() {
  1095  		ptr := v.Addr().Interface().(**string)
  1096  		if *ptr != nil {
  1097  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1098  		}
  1099  	}
  1100  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1101  	if err != nil {
  1102  		return &successPayload, err
  1103  	}
  1104  
  1105  	localVarHttpResponse, err := a.client.callAPI(r)
  1106  	if err != nil || localVarHttpResponse == nil {
  1107  		return &successPayload, err
  1108  	}
  1109  	defer localVarHttpResponse.Body.Close()
  1110  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1111  
  1112  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
  1113  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1114  	}
  1115  
  1116  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
  1117  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
  1118  			return &successPayload, err
  1119  		}
  1120  	}
  1121  
  1122  
  1123  	return &successPayload, err
  1124  }
  1125  
  1126  /* V2ApiService 
  1127   @param setNasVolumeAccessControlRequest setNasVolumeAccessControlRequest
  1128   @return *SetNasVolumeAccessControlResponse*/
  1129  func (a *V2ApiService) SetNasVolumeAccessControl(setNasVolumeAccessControlRequest *SetNasVolumeAccessControlRequest) (*SetNasVolumeAccessControlResponse, error) {
  1130  	var (
  1131  		localVarHttpMethod = strings.ToUpper("Post")
  1132  		localVarPostBody interface{}
  1133  		localVarFileName string
  1134  		localVarFileBytes []byte
  1135  	 	successPayload  SetNasVolumeAccessControlResponse
  1136  	)
  1137  
  1138  	// create path and map variables
  1139  	localVarPath := a.client.cfg.BasePath + "/setNasVolumeAccessControl"
  1140  
  1141  	localVarHeaderParams := make(map[string]string)
  1142  	localVarQueryParams := url.Values{}
  1143  	localVarFormParams := url.Values{}
  1144  
  1145  
  1146  	// to determine the Content-Type header
  1147  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
  1148  
  1149  	// set Content-Type header
  1150  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1151  	if localVarHttpContentType != "" {
  1152  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1153  	}
  1154  
  1155  	// to determine the Accept header
  1156  	localVarHttpHeaderAccepts := []string{
  1157  		}
  1158  
  1159  	// set Accept header
  1160  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1161  	if localVarHttpHeaderAccept != "" {
  1162  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1163  	}
  1164  	// body params
  1165  	localVarPostBody = setNasVolumeAccessControlRequest
  1166  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1167  	if v.IsValid() && v.CanAddr() {
  1168  		ptr := v.Addr().Interface().(**string)
  1169  		if *ptr != nil {
  1170  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1171  		}
  1172  	}
  1173  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1174  	if err != nil {
  1175  		return &successPayload, err
  1176  	}
  1177  
  1178  	localVarHttpResponse, err := a.client.callAPI(r)
  1179  	if err != nil || localVarHttpResponse == nil {
  1180  		return &successPayload, err
  1181  	}
  1182  	defer localVarHttpResponse.Body.Close()
  1183  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1184  
  1185  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
  1186  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1187  	}
  1188  
  1189  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
  1190  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
  1191  			return &successPayload, err
  1192  		}
  1193  	}
  1194  
  1195  
  1196  	return &successPayload, err
  1197  }
  1198  
  1199  /* V2ApiService 
  1200   @param setNasVolumeReturnProtectionRequest setNasVolumeReturnProtectionRequest
  1201   @return *SetNasVolumeReturnProtectionResponse*/
  1202  func (a *V2ApiService) SetNasVolumeReturnProtection(setNasVolumeReturnProtectionRequest *SetNasVolumeReturnProtectionRequest) (*SetNasVolumeReturnProtectionResponse, error) {
  1203  	var (
  1204  		localVarHttpMethod = strings.ToUpper("Post")
  1205  		localVarPostBody interface{}
  1206  		localVarFileName string
  1207  		localVarFileBytes []byte
  1208  	 	successPayload  SetNasVolumeReturnProtectionResponse
  1209  	)
  1210  
  1211  	// create path and map variables
  1212  	localVarPath := a.client.cfg.BasePath + "/setNasVolumeReturnProtection"
  1213  
  1214  	localVarHeaderParams := make(map[string]string)
  1215  	localVarQueryParams := url.Values{}
  1216  	localVarFormParams := url.Values{}
  1217  
  1218  
  1219  	// to determine the Content-Type header
  1220  	localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded",  }
  1221  
  1222  	// set Content-Type header
  1223  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1224  	if localVarHttpContentType != "" {
  1225  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1226  	}
  1227  
  1228  	// to determine the Accept header
  1229  	localVarHttpHeaderAccepts := []string{
  1230  		}
  1231  
  1232  	// set Accept header
  1233  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1234  	if localVarHttpHeaderAccept != "" {
  1235  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1236  	}
  1237  	// body params
  1238  	localVarPostBody = setNasVolumeReturnProtectionRequest
  1239  	v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData")
  1240  	if v.IsValid() && v.CanAddr() {
  1241  		ptr := v.Addr().Interface().(**string)
  1242  		if *ptr != nil {
  1243  			**ptr = base64.StdEncoding.EncodeToString([]byte(**ptr))
  1244  		}
  1245  	}
  1246  	r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1247  	if err != nil {
  1248  		return &successPayload, err
  1249  	}
  1250  
  1251  	localVarHttpResponse, err := a.client.callAPI(r)
  1252  	if err != nil || localVarHttpResponse == nil {
  1253  		return &successPayload, err
  1254  	}
  1255  	defer localVarHttpResponse.Body.Close()
  1256  	bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body)
  1257  
  1258  	if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) {
  1259  		return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes)
  1260  	}
  1261  
  1262  	if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) {
  1263  		if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil {
  1264  			return &successPayload, err
  1265  		}
  1266  	}
  1267  
  1268  
  1269  	return &successPayload, err
  1270  }
  1271