github.com/vmware/go-vmware-nsxt@v0.0.0-20230223012718-d31b8a1ca05e/upgrade_api.go (about)

     1  /* Copyright © 2017 VMware, Inc. All Rights Reserved.
     2     SPDX-License-Identifier: BSD-2-Clause
     3  
     4     Generated by: https://github.com/swagger-api/swagger-codegen.git */
     5  
     6  package nsxt
     7  
     8  import (
     9  	"context"
    10  	"encoding/json"
    11  	"fmt"
    12  	"github.com/vmware/go-vmware-nsxt/upgrade"
    13  	"net/http"
    14  	"net/url"
    15  	"strings"
    16  )
    17  
    18  // Linger please
    19  var (
    20  	_ context.Context
    21  )
    22  
    23  type UpgradeApiService service
    24  
    25  /* UpgradeApiService Add upgrade units to specified upgrade unit group
    26  Add upgrade units to specified upgrade unit group
    27  * @param ctx context.Context Authentication Context
    28  @param groupId
    29  @param upgradeUnitList
    30  @return UpgradeUnitList*/
    31  func (a *UpgradeApiService) AddUpgradeUnitsToGroupAddUpgradeUnits(ctx context.Context, groupId string, upgradeUnitList upgrade.UpgradeUnitList) (upgrade.UpgradeUnitList, *http.Response, error) {
    32  	var (
    33  		localVarHttpMethod = strings.ToUpper("Post")
    34  		localVarPostBody   interface{}
    35  		localVarFileName   string
    36  		localVarFileBytes  []byte
    37  		successPayload     upgrade.UpgradeUnitList
    38  	)
    39  
    40  	// create path and map variables
    41  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}?action=add_upgrade_units"
    42  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
    43  
    44  	localVarHeaderParams := make(map[string]string)
    45  	localVarQueryParams := url.Values{}
    46  	localVarFormParams := url.Values{}
    47  
    48  	// to determine the Content-Type header
    49  	localVarHttpContentTypes := []string{"application/json"}
    50  
    51  	// set Content-Type header
    52  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
    53  	if localVarHttpContentType != "" {
    54  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
    55  	}
    56  
    57  	// to determine the Accept header
    58  	localVarHttpHeaderAccepts := []string{
    59  		"application/json",
    60  	}
    61  
    62  	// set Accept header
    63  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
    64  	if localVarHttpHeaderAccept != "" {
    65  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
    66  	}
    67  	// body params
    68  	localVarPostBody = &upgradeUnitList
    69  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
    70  	if err != nil {
    71  		return successPayload, nil, err
    72  	}
    73  
    74  	localVarHttpResponse, err := a.client.callAPI(r)
    75  	if err != nil || localVarHttpResponse == nil {
    76  		return successPayload, localVarHttpResponse, err
    77  	}
    78  	defer localVarHttpResponse.Body.Close()
    79  	if localVarHttpResponse.StatusCode >= 300 {
    80  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
    81  	}
    82  
    83  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
    84  		return successPayload, localVarHttpResponse, err
    85  	}
    86  
    87  	return successPayload, localVarHttpResponse, err
    88  }
    89  
    90  /* UpgradeApiService Continue upgrade
    91  Continue upgrade
    92  * @param ctx context.Context Authentication Context
    93  @param optional (nil or map[string]interface{}) with one or more of:
    94      @param "skip" (bool) Skip to upgrade of next component.
    95  @return */
    96  func (a *UpgradeApiService) ContinueUpgradeContinue(ctx context.Context, localVarOptionals map[string]interface{}) (*http.Response, error) {
    97  	var (
    98  		localVarHttpMethod = strings.ToUpper("Post")
    99  		localVarPostBody   interface{}
   100  		localVarFileName   string
   101  		localVarFileBytes  []byte
   102  	)
   103  
   104  	// create path and map variables
   105  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=continue"
   106  
   107  	localVarHeaderParams := make(map[string]string)
   108  	localVarQueryParams := url.Values{}
   109  	localVarFormParams := url.Values{}
   110  
   111  	if err := typeCheckParameter(localVarOptionals["skip"], "bool", "skip"); err != nil {
   112  		return nil, err
   113  	}
   114  
   115  	if localVarTempParam, localVarOk := localVarOptionals["skip"].(bool); localVarOk {
   116  		localVarQueryParams.Add("skip", parameterToString(localVarTempParam, ""))
   117  	}
   118  	// to determine the Content-Type header
   119  	localVarHttpContentTypes := []string{"application/json"}
   120  
   121  	// set Content-Type header
   122  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   123  	if localVarHttpContentType != "" {
   124  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   125  	}
   126  
   127  	// to determine the Accept header
   128  	localVarHttpHeaderAccepts := []string{
   129  		"application/json",
   130  	}
   131  
   132  	// set Accept header
   133  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   134  	if localVarHttpHeaderAccept != "" {
   135  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   136  	}
   137  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   138  	if err != nil {
   139  		return nil, err
   140  	}
   141  
   142  	localVarHttpResponse, err := a.client.callAPI(r)
   143  	if err != nil || localVarHttpResponse == nil {
   144  		return localVarHttpResponse, err
   145  	}
   146  	defer localVarHttpResponse.Body.Close()
   147  	if localVarHttpResponse.StatusCode >= 300 {
   148  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
   149  	}
   150  
   151  	return localVarHttpResponse, err
   152  }
   153  
   154  /* UpgradeApiService Create a group
   155  Create a group
   156  * @param ctx context.Context Authentication Context
   157  @param upgradeUnitGroup
   158  @return upgrade.UpgradeUnitGroup*/
   159  func (a *UpgradeApiService) CreateUpgradeUnitGroup(ctx context.Context, upgradeUnitGroup upgrade.UpgradeUnitGroup) (upgrade.UpgradeUnitGroup, *http.Response, error) {
   160  	var (
   161  		localVarHttpMethod = strings.ToUpper("Post")
   162  		localVarPostBody   interface{}
   163  		localVarFileName   string
   164  		localVarFileBytes  []byte
   165  		successPayload     upgrade.UpgradeUnitGroup
   166  	)
   167  
   168  	// create path and map variables
   169  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups"
   170  
   171  	localVarHeaderParams := make(map[string]string)
   172  	localVarQueryParams := url.Values{}
   173  	localVarFormParams := url.Values{}
   174  
   175  	// to determine the Content-Type header
   176  	localVarHttpContentTypes := []string{"application/json"}
   177  
   178  	// set Content-Type header
   179  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   180  	if localVarHttpContentType != "" {
   181  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   182  	}
   183  
   184  	// to determine the Accept header
   185  	localVarHttpHeaderAccepts := []string{
   186  		"application/json",
   187  	}
   188  
   189  	// set Accept header
   190  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   191  	if localVarHttpHeaderAccept != "" {
   192  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   193  	}
   194  	// body params
   195  	localVarPostBody = &upgradeUnitGroup
   196  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   197  	if err != nil {
   198  		return successPayload, nil, err
   199  	}
   200  
   201  	localVarHttpResponse, err := a.client.callAPI(r)
   202  	if err != nil || localVarHttpResponse == nil {
   203  		return successPayload, localVarHttpResponse, err
   204  	}
   205  	defer localVarHttpResponse.Body.Close()
   206  	if localVarHttpResponse.StatusCode >= 300 {
   207  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   208  	}
   209  
   210  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   211  		return successPayload, localVarHttpResponse, err
   212  	}
   213  
   214  	return successPayload, localVarHttpResponse, err
   215  }
   216  
   217  /* UpgradeApiService Delete the upgrade unit group
   218  Delete the upgrade unit group
   219  * @param ctx context.Context Authentication Context
   220  @param groupId
   221  @return */
   222  func (a *UpgradeApiService) DeleteUpgradeUnitGroup(ctx context.Context, groupId string) (*http.Response, error) {
   223  	var (
   224  		localVarHttpMethod = strings.ToUpper("Delete")
   225  		localVarPostBody   interface{}
   226  		localVarFileName   string
   227  		localVarFileBytes  []byte
   228  	)
   229  
   230  	// create path and map variables
   231  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}"
   232  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
   233  
   234  	localVarHeaderParams := make(map[string]string)
   235  	localVarQueryParams := url.Values{}
   236  	localVarFormParams := url.Values{}
   237  
   238  	// to determine the Content-Type header
   239  	localVarHttpContentTypes := []string{"application/json"}
   240  
   241  	// set Content-Type header
   242  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   243  	if localVarHttpContentType != "" {
   244  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   245  	}
   246  
   247  	// to determine the Accept header
   248  	localVarHttpHeaderAccepts := []string{
   249  		"application/json",
   250  	}
   251  
   252  	// set Accept header
   253  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   254  	if localVarHttpHeaderAccept != "" {
   255  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   256  	}
   257  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   258  	if err != nil {
   259  		return nil, err
   260  	}
   261  
   262  	localVarHttpResponse, err := a.client.callAPI(r)
   263  	if err != nil || localVarHttpResponse == nil {
   264  		return localVarHttpResponse, err
   265  	}
   266  	defer localVarHttpResponse.Body.Close()
   267  	if localVarHttpResponse.StatusCode >= 300 {
   268  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
   269  	}
   270  
   271  	return localVarHttpResponse, err
   272  }
   273  
   274  /* UpgradeApiService Get list of nodes across all types
   275  Get list of nodes across all types
   276  * @param ctx context.Context Authentication Context
   277  @param optional (nil or map[string]interface{}) with one or more of:
   278      @param "componentType" (string) Component type based on which nodes will be filtered
   279      @param "componentVersion" (string) Component version based on which nodes will be filtered
   280      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
   281      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
   282      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
   283      @param "sortAscending" (bool)
   284      @param "sortBy" (string) Field by which records are sorted
   285  @return upgrade.NodeInfoListResult*/
   286  func (a *UpgradeApiService) GetNodes(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.NodeInfoListResult, *http.Response, error) {
   287  	var (
   288  		localVarHttpMethod = strings.ToUpper("Get")
   289  		localVarPostBody   interface{}
   290  		localVarFileName   string
   291  		localVarFileBytes  []byte
   292  		successPayload     upgrade.NodeInfoListResult
   293  	)
   294  
   295  	// create path and map variables
   296  	localVarPath := a.client.cfg.BasePath + "/upgrade/nodes"
   297  
   298  	localVarHeaderParams := make(map[string]string)
   299  	localVarQueryParams := url.Values{}
   300  	localVarFormParams := url.Values{}
   301  
   302  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
   303  		return successPayload, nil, err
   304  	}
   305  	if err := typeCheckParameter(localVarOptionals["componentVersion"], "string", "componentVersion"); err != nil {
   306  		return successPayload, nil, err
   307  	}
   308  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
   309  		return successPayload, nil, err
   310  	}
   311  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
   312  		return successPayload, nil, err
   313  	}
   314  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
   315  		return successPayload, nil, err
   316  	}
   317  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
   318  		return successPayload, nil, err
   319  	}
   320  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
   321  		return successPayload, nil, err
   322  	}
   323  
   324  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
   325  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
   326  	}
   327  	if localVarTempParam, localVarOk := localVarOptionals["componentVersion"].(string); localVarOk {
   328  		localVarQueryParams.Add("component_version", parameterToString(localVarTempParam, ""))
   329  	}
   330  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
   331  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
   332  	}
   333  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
   334  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
   335  	}
   336  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
   337  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
   338  	}
   339  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
   340  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
   341  	}
   342  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
   343  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
   344  	}
   345  	// to determine the Content-Type header
   346  	localVarHttpContentTypes := []string{"application/json"}
   347  
   348  	// set Content-Type header
   349  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   350  	if localVarHttpContentType != "" {
   351  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   352  	}
   353  
   354  	// to determine the Accept header
   355  	localVarHttpHeaderAccepts := []string{
   356  		"application/json",
   357  	}
   358  
   359  	// set Accept header
   360  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   361  	if localVarHttpHeaderAccept != "" {
   362  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   363  	}
   364  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   365  	if err != nil {
   366  		return successPayload, nil, err
   367  	}
   368  
   369  	localVarHttpResponse, err := a.client.callAPI(r)
   370  	if err != nil || localVarHttpResponse == nil {
   371  		return successPayload, localVarHttpResponse, err
   372  	}
   373  	defer localVarHttpResponse.Body.Close()
   374  	if localVarHttpResponse.StatusCode >= 300 {
   375  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   376  	}
   377  
   378  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   379  		return successPayload, localVarHttpResponse, err
   380  	}
   381  
   382  	return successPayload, localVarHttpResponse, err
   383  }
   384  
   385  /* UpgradeApiService Get summary of nodes
   386  Get summary of nodes
   387  * @param ctx context.Context Authentication Context
   388  @return upgrade.NodeSummaryList*/
   389  func (a *UpgradeApiService) GetNodesSummary(ctx context.Context) (upgrade.NodeSummaryList, *http.Response, error) {
   390  	var (
   391  		localVarHttpMethod = strings.ToUpper("Get")
   392  		localVarPostBody   interface{}
   393  		localVarFileName   string
   394  		localVarFileBytes  []byte
   395  		successPayload     upgrade.NodeSummaryList
   396  	)
   397  
   398  	// create path and map variables
   399  	localVarPath := a.client.cfg.BasePath + "/upgrade/nodes-summary"
   400  
   401  	localVarHeaderParams := make(map[string]string)
   402  	localVarQueryParams := url.Values{}
   403  	localVarFormParams := url.Values{}
   404  
   405  	// to determine the Content-Type header
   406  	localVarHttpContentTypes := []string{"application/json"}
   407  
   408  	// set Content-Type header
   409  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   410  	if localVarHttpContentType != "" {
   411  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   412  	}
   413  
   414  	// to determine the Accept header
   415  	localVarHttpHeaderAccepts := []string{
   416  		"application/json",
   417  	}
   418  
   419  	// set Accept header
   420  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   421  	if localVarHttpHeaderAccept != "" {
   422  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   423  	}
   424  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   425  	if err != nil {
   426  		return successPayload, nil, err
   427  	}
   428  
   429  	localVarHttpResponse, err := a.client.callAPI(r)
   430  	if err != nil || localVarHttpResponse == nil {
   431  		return successPayload, localVarHttpResponse, err
   432  	}
   433  	defer localVarHttpResponse.Body.Close()
   434  	if localVarHttpResponse.StatusCode >= 300 {
   435  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   436  	}
   437  
   438  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   439  		return successPayload, localVarHttpResponse, err
   440  	}
   441  
   442  	return successPayload, localVarHttpResponse, err
   443  }
   444  
   445  /* UpgradeApiService Get upgrade history
   446  Get upgrade history
   447  * @param ctx context.Context Authentication Context
   448  @return UpgradeHistoryList*/
   449  func (a *UpgradeApiService) GetUpgradeHistory(ctx context.Context) (upgrade.UpgradeHistoryList, *http.Response, error) {
   450  	var (
   451  		localVarHttpMethod = strings.ToUpper("Get")
   452  		localVarPostBody   interface{}
   453  		localVarFileName   string
   454  		localVarFileBytes  []byte
   455  		successPayload     upgrade.UpgradeHistoryList
   456  	)
   457  
   458  	// create path and map variables
   459  	localVarPath := a.client.cfg.BasePath + "/upgrade/history"
   460  
   461  	localVarHeaderParams := make(map[string]string)
   462  	localVarQueryParams := url.Values{}
   463  	localVarFormParams := url.Values{}
   464  
   465  	// to determine the Content-Type header
   466  	localVarHttpContentTypes := []string{"application/json"}
   467  
   468  	// set Content-Type header
   469  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   470  	if localVarHttpContentType != "" {
   471  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   472  	}
   473  
   474  	// to determine the Accept header
   475  	localVarHttpHeaderAccepts := []string{
   476  		"application/json",
   477  	}
   478  
   479  	// set Accept header
   480  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   481  	if localVarHttpHeaderAccept != "" {
   482  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   483  	}
   484  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   485  	if err != nil {
   486  		return successPayload, nil, err
   487  	}
   488  
   489  	localVarHttpResponse, err := a.client.callAPI(r)
   490  	if err != nil || localVarHttpResponse == nil {
   491  		return successPayload, localVarHttpResponse, err
   492  	}
   493  	defer localVarHttpResponse.Body.Close()
   494  	if localVarHttpResponse.StatusCode >= 300 {
   495  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   496  	}
   497  
   498  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   499  		return successPayload, localVarHttpResponse, err
   500  	}
   501  
   502  	return successPayload, localVarHttpResponse, err
   503  }
   504  
   505  /* UpgradeApiService Get upgrade plan settings for the component
   506  Get the upgrade plan settings for the component.
   507  * @param ctx context.Context Authentication Context
   508  @param componentType
   509  @return UpgradePlanSettings*/
   510  func (a *UpgradeApiService) GetUpgradePlanSettings(ctx context.Context, componentType string) (upgrade.UpgradePlanSettings, *http.Response, error) {
   511  	var (
   512  		localVarHttpMethod = strings.ToUpper("Get")
   513  		localVarPostBody   interface{}
   514  		localVarFileName   string
   515  		localVarFileBytes  []byte
   516  		successPayload     upgrade.UpgradePlanSettings
   517  	)
   518  
   519  	// create path and map variables
   520  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan/{component_type}/settings"
   521  	localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1)
   522  
   523  	localVarHeaderParams := make(map[string]string)
   524  	localVarQueryParams := url.Values{}
   525  	localVarFormParams := url.Values{}
   526  
   527  	// to determine the Content-Type header
   528  	localVarHttpContentTypes := []string{"application/json"}
   529  
   530  	// set Content-Type header
   531  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   532  	if localVarHttpContentType != "" {
   533  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   534  	}
   535  
   536  	// to determine the Accept header
   537  	localVarHttpHeaderAccepts := []string{
   538  		"application/json",
   539  	}
   540  
   541  	// set Accept header
   542  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   543  	if localVarHttpHeaderAccept != "" {
   544  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   545  	}
   546  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   547  	if err != nil {
   548  		return successPayload, nil, err
   549  	}
   550  
   551  	localVarHttpResponse, err := a.client.callAPI(r)
   552  	if err != nil || localVarHttpResponse == nil {
   553  		return successPayload, localVarHttpResponse, err
   554  	}
   555  	defer localVarHttpResponse.Body.Close()
   556  	if localVarHttpResponse.StatusCode >= 300 {
   557  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   558  	}
   559  
   560  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   561  		return successPayload, localVarHttpResponse, err
   562  	}
   563  
   564  	return successPayload, localVarHttpResponse, err
   565  }
   566  
   567  /* UpgradeApiService Get upgrade status summary
   568  Get upgrade status summary
   569  * @param ctx context.Context Authentication Context
   570  @param optional (nil or map[string]interface{}) with one or more of:
   571      @param "componentType" (string) Component type based on which upgrade units to be filtered
   572      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
   573      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
   574      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
   575      @param "selectionStatus" (string) Flag to indicate whether to return status for only selected, only deselected or both type of upgrade units
   576      @param "sortAscending" (bool)
   577      @param "sortBy" (string) Field by which records are sorted
   578  @return UpgradeStatus*/
   579  func (a *UpgradeApiService) GetUpgradeStatusSummary(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeStatus, *http.Response, error) {
   580  	var (
   581  		localVarHttpMethod = strings.ToUpper("Get")
   582  		localVarPostBody   interface{}
   583  		localVarFileName   string
   584  		localVarFileBytes  []byte
   585  		successPayload     upgrade.UpgradeStatus
   586  	)
   587  
   588  	// create path and map variables
   589  	localVarPath := a.client.cfg.BasePath + "/upgrade/status-summary"
   590  
   591  	localVarHeaderParams := make(map[string]string)
   592  	localVarQueryParams := url.Values{}
   593  	localVarFormParams := url.Values{}
   594  
   595  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
   596  		return successPayload, nil, err
   597  	}
   598  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
   599  		return successPayload, nil, err
   600  	}
   601  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
   602  		return successPayload, nil, err
   603  	}
   604  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
   605  		return successPayload, nil, err
   606  	}
   607  	if err := typeCheckParameter(localVarOptionals["selectionStatus"], "string", "selectionStatus"); err != nil {
   608  		return successPayload, nil, err
   609  	}
   610  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
   611  		return successPayload, nil, err
   612  	}
   613  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
   614  		return successPayload, nil, err
   615  	}
   616  
   617  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
   618  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
   619  	}
   620  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
   621  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
   622  	}
   623  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
   624  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
   625  	}
   626  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
   627  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
   628  	}
   629  	if localVarTempParam, localVarOk := localVarOptionals["selectionStatus"].(string); localVarOk {
   630  		localVarQueryParams.Add("selection_status", parameterToString(localVarTempParam, ""))
   631  	}
   632  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
   633  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
   634  	}
   635  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
   636  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
   637  	}
   638  	// to determine the Content-Type header
   639  	localVarHttpContentTypes := []string{"application/json"}
   640  
   641  	// set Content-Type header
   642  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   643  	if localVarHttpContentType != "" {
   644  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   645  	}
   646  
   647  	// to determine the Accept header
   648  	localVarHttpHeaderAccepts := []string{
   649  		"application/json",
   650  	}
   651  
   652  	// set Accept header
   653  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   654  	if localVarHttpHeaderAccept != "" {
   655  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   656  	}
   657  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   658  	if err != nil {
   659  		return successPayload, nil, err
   660  	}
   661  
   662  	localVarHttpResponse, err := a.client.callAPI(r)
   663  	if err != nil || localVarHttpResponse == nil {
   664  		return successPayload, localVarHttpResponse, err
   665  	}
   666  	defer localVarHttpResponse.Body.Close()
   667  	if localVarHttpResponse.StatusCode >= 300 {
   668  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   669  	}
   670  
   671  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   672  		return successPayload, localVarHttpResponse, err
   673  	}
   674  
   675  	return successPayload, localVarHttpResponse, err
   676  }
   677  
   678  /* UpgradeApiService Get upgrade summary
   679  Get upgrade summary
   680  * @param ctx context.Context Authentication Context
   681  @return UpgradeSummary*/
   682  func (a *UpgradeApiService) GetUpgradeSummary(ctx context.Context) (upgrade.UpgradeSummary, *http.Response, error) {
   683  	var (
   684  		localVarHttpMethod = strings.ToUpper("Get")
   685  		localVarPostBody   interface{}
   686  		localVarFileName   string
   687  		localVarFileBytes  []byte
   688  		successPayload     upgrade.UpgradeSummary
   689  	)
   690  
   691  	// create path and map variables
   692  	localVarPath := a.client.cfg.BasePath + "/upgrade/summary"
   693  
   694  	localVarHeaderParams := make(map[string]string)
   695  	localVarQueryParams := url.Values{}
   696  	localVarFormParams := url.Values{}
   697  
   698  	// to determine the Content-Type header
   699  	localVarHttpContentTypes := []string{"application/json"}
   700  
   701  	// set Content-Type header
   702  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   703  	if localVarHttpContentType != "" {
   704  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   705  	}
   706  
   707  	// to determine the Accept header
   708  	localVarHttpHeaderAccepts := []string{
   709  		"application/json",
   710  	}
   711  
   712  	// set Accept header
   713  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   714  	if localVarHttpHeaderAccept != "" {
   715  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   716  	}
   717  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   718  	if err != nil {
   719  		return successPayload, nil, err
   720  	}
   721  
   722  	localVarHttpResponse, err := a.client.callAPI(r)
   723  	if err != nil || localVarHttpResponse == nil {
   724  		return successPayload, localVarHttpResponse, err
   725  	}
   726  	defer localVarHttpResponse.Body.Close()
   727  	if localVarHttpResponse.StatusCode >= 300 {
   728  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   729  	}
   730  
   731  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   732  		return successPayload, localVarHttpResponse, err
   733  	}
   734  
   735  	return successPayload, localVarHttpResponse, err
   736  }
   737  
   738  /* UpgradeApiService Get a specific upgrade unit
   739  Get a specific upgrade unit
   740  * @param ctx context.Context Authentication Context
   741  @param upgradeUnitId
   742  @return UpgradeUnit*/
   743  func (a *UpgradeApiService) GetUpgradeUnit(ctx context.Context, upgradeUnitId string) (upgrade.UpgradeUnit, *http.Response, error) {
   744  	var (
   745  		localVarHttpMethod = strings.ToUpper("Get")
   746  		localVarPostBody   interface{}
   747  		localVarFileName   string
   748  		localVarFileBytes  []byte
   749  		successPayload     upgrade.UpgradeUnit
   750  	)
   751  
   752  	// create path and map variables
   753  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units/{upgrade-unit-id}"
   754  	localVarPath = strings.Replace(localVarPath, "{"+"upgrade-unit-id"+"}", fmt.Sprintf("%v", upgradeUnitId), -1)
   755  
   756  	localVarHeaderParams := make(map[string]string)
   757  	localVarQueryParams := url.Values{}
   758  	localVarFormParams := url.Values{}
   759  
   760  	// to determine the Content-Type header
   761  	localVarHttpContentTypes := []string{"application/json"}
   762  
   763  	// set Content-Type header
   764  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   765  	if localVarHttpContentType != "" {
   766  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   767  	}
   768  
   769  	// to determine the Accept header
   770  	localVarHttpHeaderAccepts := []string{
   771  		"application/json",
   772  	}
   773  
   774  	// set Accept header
   775  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   776  	if localVarHttpHeaderAccept != "" {
   777  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   778  	}
   779  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   780  	if err != nil {
   781  		return successPayload, nil, err
   782  	}
   783  
   784  	localVarHttpResponse, err := a.client.callAPI(r)
   785  	if err != nil || localVarHttpResponse == nil {
   786  		return successPayload, localVarHttpResponse, err
   787  	}
   788  	defer localVarHttpResponse.Body.Close()
   789  	if localVarHttpResponse.StatusCode >= 300 {
   790  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   791  	}
   792  
   793  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   794  		return successPayload, localVarHttpResponse, err
   795  	}
   796  
   797  	return successPayload, localVarHttpResponse, err
   798  }
   799  
   800  /* UpgradeApiService Get upgrade units aggregate-info
   801  Get upgrade units aggregate-info
   802  * @param ctx context.Context Authentication Context
   803  @param optional (nil or map[string]interface{}) with one or more of:
   804      @param "componentType" (string) Component type based on which upgrade units to be filtered
   805      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
   806      @param "groupId" (string) Identifier of group based on which upgrade units to be filtered
   807      @param "hasErrors" (bool) Flag to indicate whether to return only upgrade units with errors
   808      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
   809      @param "metadata" (string) Metadata about upgrade unit to filter on
   810      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
   811      @param "selectionStatus" (string) Flag to indicate whether to return only selected, only deselected or both type of upgrade units
   812      @param "sortAscending" (bool)
   813      @param "sortBy" (string) Field by which records are sorted
   814  @return UpgradeUnitAggregateInfoListResult*/
   815  func (a *UpgradeApiService) GetUpgradeUnitAggregateInfo(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitAggregateInfoListResult, *http.Response, error) {
   816  	var (
   817  		localVarHttpMethod = strings.ToUpper("Get")
   818  		localVarPostBody   interface{}
   819  		localVarFileName   string
   820  		localVarFileBytes  []byte
   821  		successPayload     upgrade.UpgradeUnitAggregateInfoListResult
   822  	)
   823  
   824  	// create path and map variables
   825  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units/aggregate-info"
   826  
   827  	localVarHeaderParams := make(map[string]string)
   828  	localVarQueryParams := url.Values{}
   829  	localVarFormParams := url.Values{}
   830  
   831  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
   832  		return successPayload, nil, err
   833  	}
   834  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
   835  		return successPayload, nil, err
   836  	}
   837  	if err := typeCheckParameter(localVarOptionals["groupId"], "string", "groupId"); err != nil {
   838  		return successPayload, nil, err
   839  	}
   840  	if err := typeCheckParameter(localVarOptionals["hasErrors"], "bool", "hasErrors"); err != nil {
   841  		return successPayload, nil, err
   842  	}
   843  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
   844  		return successPayload, nil, err
   845  	}
   846  	if err := typeCheckParameter(localVarOptionals["metadata"], "string", "metadata"); err != nil {
   847  		return successPayload, nil, err
   848  	}
   849  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
   850  		return successPayload, nil, err
   851  	}
   852  	if err := typeCheckParameter(localVarOptionals["selectionStatus"], "string", "selectionStatus"); err != nil {
   853  		return successPayload, nil, err
   854  	}
   855  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
   856  		return successPayload, nil, err
   857  	}
   858  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
   859  		return successPayload, nil, err
   860  	}
   861  
   862  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
   863  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
   864  	}
   865  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
   866  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
   867  	}
   868  	if localVarTempParam, localVarOk := localVarOptionals["groupId"].(string); localVarOk {
   869  		localVarQueryParams.Add("group_id", parameterToString(localVarTempParam, ""))
   870  	}
   871  	if localVarTempParam, localVarOk := localVarOptionals["hasErrors"].(bool); localVarOk {
   872  		localVarQueryParams.Add("has_errors", parameterToString(localVarTempParam, ""))
   873  	}
   874  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
   875  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
   876  	}
   877  	if localVarTempParam, localVarOk := localVarOptionals["metadata"].(string); localVarOk {
   878  		localVarQueryParams.Add("metadata", parameterToString(localVarTempParam, ""))
   879  	}
   880  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
   881  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
   882  	}
   883  	if localVarTempParam, localVarOk := localVarOptionals["selectionStatus"].(string); localVarOk {
   884  		localVarQueryParams.Add("selection_status", parameterToString(localVarTempParam, ""))
   885  	}
   886  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
   887  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
   888  	}
   889  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
   890  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
   891  	}
   892  	// to determine the Content-Type header
   893  	localVarHttpContentTypes := []string{"application/json"}
   894  
   895  	// set Content-Type header
   896  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   897  	if localVarHttpContentType != "" {
   898  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   899  	}
   900  
   901  	// to determine the Accept header
   902  	localVarHttpHeaderAccepts := []string{
   903  		"application/json",
   904  	}
   905  
   906  	// set Accept header
   907  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   908  	if localVarHttpHeaderAccept != "" {
   909  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   910  	}
   911  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   912  	if err != nil {
   913  		return successPayload, nil, err
   914  	}
   915  
   916  	localVarHttpResponse, err := a.client.callAPI(r)
   917  	if err != nil || localVarHttpResponse == nil {
   918  		return successPayload, localVarHttpResponse, err
   919  	}
   920  	defer localVarHttpResponse.Body.Close()
   921  	if localVarHttpResponse.StatusCode >= 300 {
   922  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   923  	}
   924  
   925  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   926  		return successPayload, localVarHttpResponse, err
   927  	}
   928  
   929  	return successPayload, localVarHttpResponse, err
   930  }
   931  
   932  /* UpgradeApiService Return upgrade unit group information
   933  Return upgrade unit group information
   934  * @param ctx context.Context Authentication Context
   935  @param groupId
   936  @param optional (nil or map[string]interface{}) with one or more of:
   937      @param "summary" (bool) Flag indicating whether to return the summary
   938  @return upgrade.UpgradeUnitGroup*/
   939  func (a *UpgradeApiService) GetUpgradeUnitGroup(ctx context.Context, groupId string, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroup, *http.Response, error) {
   940  	var (
   941  		localVarHttpMethod = strings.ToUpper("Get")
   942  		localVarPostBody   interface{}
   943  		localVarFileName   string
   944  		localVarFileBytes  []byte
   945  		successPayload     upgrade.UpgradeUnitGroup
   946  	)
   947  
   948  	// create path and map variables
   949  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}"
   950  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
   951  
   952  	localVarHeaderParams := make(map[string]string)
   953  	localVarQueryParams := url.Values{}
   954  	localVarFormParams := url.Values{}
   955  
   956  	if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil {
   957  		return successPayload, nil, err
   958  	}
   959  
   960  	if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk {
   961  		localVarQueryParams.Add("summary", parameterToString(localVarTempParam, ""))
   962  	}
   963  	// to determine the Content-Type header
   964  	localVarHttpContentTypes := []string{"application/json"}
   965  
   966  	// set Content-Type header
   967  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   968  	if localVarHttpContentType != "" {
   969  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   970  	}
   971  
   972  	// to determine the Accept header
   973  	localVarHttpHeaderAccepts := []string{
   974  		"application/json",
   975  	}
   976  
   977  	// set Accept header
   978  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   979  	if localVarHttpHeaderAccept != "" {
   980  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   981  	}
   982  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   983  	if err != nil {
   984  		return successPayload, nil, err
   985  	}
   986  
   987  	localVarHttpResponse, err := a.client.callAPI(r)
   988  	if err != nil || localVarHttpResponse == nil {
   989  		return successPayload, localVarHttpResponse, err
   990  	}
   991  	defer localVarHttpResponse.Body.Close()
   992  	if localVarHttpResponse.StatusCode >= 300 {
   993  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   994  	}
   995  
   996  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   997  		return successPayload, localVarHttpResponse, err
   998  	}
   999  
  1000  	return successPayload, localVarHttpResponse, err
  1001  }
  1002  
  1003  /* UpgradeApiService Return aggregate information of all upgrade unit groups
  1004  Return aggregate information of all upgrade unit groups
  1005  * @param ctx context.Context Authentication Context
  1006  @param optional (nil or map[string]interface{}) with one or more of:
  1007      @param "componentType" (string) Component type based on which upgrade unit groups to be filtered
  1008      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1009      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1010      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1011      @param "sortAscending" (bool)
  1012      @param "sortBy" (string) Field by which records are sorted
  1013      @param "summary" (bool) Flag indicating whether to return summary
  1014      @param "sync" (bool) Synchronize before returning upgrade unit groups
  1015  @return upgrade.UpgradeUnitGroupAggregateInfoListResult*/
  1016  func (a *UpgradeApiService) GetUpgradeUnitGroupAggregateInfo(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupAggregateInfoListResult, *http.Response, error) {
  1017  	var (
  1018  		localVarHttpMethod = strings.ToUpper("Get")
  1019  		localVarPostBody   interface{}
  1020  		localVarFileName   string
  1021  		localVarFileBytes  []byte
  1022  		successPayload     upgrade.UpgradeUnitGroupAggregateInfoListResult
  1023  	)
  1024  
  1025  	// create path and map variables
  1026  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/aggregate-info"
  1027  
  1028  	localVarHeaderParams := make(map[string]string)
  1029  	localVarQueryParams := url.Values{}
  1030  	localVarFormParams := url.Values{}
  1031  
  1032  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
  1033  		return successPayload, nil, err
  1034  	}
  1035  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1036  		return successPayload, nil, err
  1037  	}
  1038  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1039  		return successPayload, nil, err
  1040  	}
  1041  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1042  		return successPayload, nil, err
  1043  	}
  1044  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1045  		return successPayload, nil, err
  1046  	}
  1047  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1048  		return successPayload, nil, err
  1049  	}
  1050  	if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil {
  1051  		return successPayload, nil, err
  1052  	}
  1053  	if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil {
  1054  		return successPayload, nil, err
  1055  	}
  1056  
  1057  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
  1058  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
  1059  	}
  1060  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1061  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1062  	}
  1063  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1064  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1065  	}
  1066  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1067  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1068  	}
  1069  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1070  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1071  	}
  1072  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1073  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1074  	}
  1075  	if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk {
  1076  		localVarQueryParams.Add("summary", parameterToString(localVarTempParam, ""))
  1077  	}
  1078  	if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk {
  1079  		localVarQueryParams.Add("sync", parameterToString(localVarTempParam, ""))
  1080  	}
  1081  	// to determine the Content-Type header
  1082  	localVarHttpContentTypes := []string{"application/json"}
  1083  
  1084  	// set Content-Type header
  1085  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1086  	if localVarHttpContentType != "" {
  1087  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1088  	}
  1089  
  1090  	// to determine the Accept header
  1091  	localVarHttpHeaderAccepts := []string{
  1092  		"application/json",
  1093  	}
  1094  
  1095  	// set Accept header
  1096  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1097  	if localVarHttpHeaderAccept != "" {
  1098  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1099  	}
  1100  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1101  	if err != nil {
  1102  		return successPayload, nil, err
  1103  	}
  1104  
  1105  	localVarHttpResponse, err := a.client.callAPI(r)
  1106  	if err != nil || localVarHttpResponse == nil {
  1107  		return successPayload, localVarHttpResponse, err
  1108  	}
  1109  	defer localVarHttpResponse.Body.Close()
  1110  	if localVarHttpResponse.StatusCode >= 300 {
  1111  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1112  	}
  1113  
  1114  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1115  		return successPayload, localVarHttpResponse, err
  1116  	}
  1117  
  1118  	return successPayload, localVarHttpResponse, err
  1119  }
  1120  
  1121  /* UpgradeApiService Get upgrade status for group
  1122  Get upgrade status for group
  1123  * @param ctx context.Context Authentication Context
  1124  @param groupId
  1125  @param optional (nil or map[string]interface{}) with one or more of:
  1126      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1127      @param "hasErrors" (bool) Flag to indicate whether to return only upgrade units with errors
  1128      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1129      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1130      @param "sortAscending" (bool)
  1131      @param "sortBy" (string) Field by which records are sorted
  1132  @return UpgradeUnitStatusListResult*/
  1133  func (a *UpgradeApiService) GetUpgradeUnitGroupStatus(ctx context.Context, groupId string, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitStatusListResult, *http.Response, error) {
  1134  	var (
  1135  		localVarHttpMethod = strings.ToUpper("Get")
  1136  		localVarPostBody   interface{}
  1137  		localVarFileName   string
  1138  		localVarFileBytes  []byte
  1139  		successPayload     upgrade.UpgradeUnitStatusListResult
  1140  	)
  1141  
  1142  	// create path and map variables
  1143  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}/status"
  1144  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
  1145  
  1146  	localVarHeaderParams := make(map[string]string)
  1147  	localVarQueryParams := url.Values{}
  1148  	localVarFormParams := url.Values{}
  1149  
  1150  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1151  		return successPayload, nil, err
  1152  	}
  1153  	if err := typeCheckParameter(localVarOptionals["hasErrors"], "bool", "hasErrors"); err != nil {
  1154  		return successPayload, nil, err
  1155  	}
  1156  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1157  		return successPayload, nil, err
  1158  	}
  1159  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1160  		return successPayload, nil, err
  1161  	}
  1162  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1163  		return successPayload, nil, err
  1164  	}
  1165  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1166  		return successPayload, nil, err
  1167  	}
  1168  
  1169  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1170  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1171  	}
  1172  	if localVarTempParam, localVarOk := localVarOptionals["hasErrors"].(bool); localVarOk {
  1173  		localVarQueryParams.Add("has_errors", parameterToString(localVarTempParam, ""))
  1174  	}
  1175  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1176  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1177  	}
  1178  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1179  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1180  	}
  1181  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1182  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1183  	}
  1184  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1185  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1186  	}
  1187  	// to determine the Content-Type header
  1188  	localVarHttpContentTypes := []string{"application/json"}
  1189  
  1190  	// set Content-Type header
  1191  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1192  	if localVarHttpContentType != "" {
  1193  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1194  	}
  1195  
  1196  	// to determine the Accept header
  1197  	localVarHttpHeaderAccepts := []string{
  1198  		"application/json",
  1199  	}
  1200  
  1201  	// set Accept header
  1202  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1203  	if localVarHttpHeaderAccept != "" {
  1204  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1205  	}
  1206  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1207  	if err != nil {
  1208  		return successPayload, nil, err
  1209  	}
  1210  
  1211  	localVarHttpResponse, err := a.client.callAPI(r)
  1212  	if err != nil || localVarHttpResponse == nil {
  1213  		return successPayload, localVarHttpResponse, err
  1214  	}
  1215  	defer localVarHttpResponse.Body.Close()
  1216  	if localVarHttpResponse.StatusCode >= 300 {
  1217  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1218  	}
  1219  
  1220  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1221  		return successPayload, localVarHttpResponse, err
  1222  	}
  1223  
  1224  	return successPayload, localVarHttpResponse, err
  1225  }
  1226  
  1227  /* UpgradeApiService Return information of all upgrade unit groups
  1228  Return information of all upgrade unit groups
  1229  * @param ctx context.Context Authentication Context
  1230  @param optional (nil or map[string]interface{}) with one or more of:
  1231      @param "componentType" (string) Component type based on which upgrade unit groups to be filtered
  1232      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1233      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1234      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1235      @param "sortAscending" (bool)
  1236      @param "sortBy" (string) Field by which records are sorted
  1237      @param "summary" (bool) Flag indicating whether to return summary
  1238      @param "sync" (bool) Synchronize before returning upgrade unit groups
  1239  @return upgrade.UpgradeUnitGroupListResult*/
  1240  func (a *UpgradeApiService) GetUpgradeUnitGroups(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupListResult, *http.Response, error) {
  1241  	var (
  1242  		localVarHttpMethod = strings.ToUpper("Get")
  1243  		localVarPostBody   interface{}
  1244  		localVarFileName   string
  1245  		localVarFileBytes  []byte
  1246  		successPayload     upgrade.UpgradeUnitGroupListResult
  1247  	)
  1248  
  1249  	// create path and map variables
  1250  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups"
  1251  
  1252  	localVarHeaderParams := make(map[string]string)
  1253  	localVarQueryParams := url.Values{}
  1254  	localVarFormParams := url.Values{}
  1255  
  1256  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
  1257  		return successPayload, nil, err
  1258  	}
  1259  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1260  		return successPayload, nil, err
  1261  	}
  1262  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1263  		return successPayload, nil, err
  1264  	}
  1265  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1266  		return successPayload, nil, err
  1267  	}
  1268  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1269  		return successPayload, nil, err
  1270  	}
  1271  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1272  		return successPayload, nil, err
  1273  	}
  1274  	if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil {
  1275  		return successPayload, nil, err
  1276  	}
  1277  	if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil {
  1278  		return successPayload, nil, err
  1279  	}
  1280  
  1281  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
  1282  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
  1283  	}
  1284  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1285  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1286  	}
  1287  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1288  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1289  	}
  1290  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1291  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1292  	}
  1293  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1294  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1295  	}
  1296  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1297  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1298  	}
  1299  	if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk {
  1300  		localVarQueryParams.Add("summary", parameterToString(localVarTempParam, ""))
  1301  	}
  1302  	if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk {
  1303  		localVarQueryParams.Add("sync", parameterToString(localVarTempParam, ""))
  1304  	}
  1305  	// to determine the Content-Type header
  1306  	localVarHttpContentTypes := []string{"application/json"}
  1307  
  1308  	// set Content-Type header
  1309  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1310  	if localVarHttpContentType != "" {
  1311  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1312  	}
  1313  
  1314  	// to determine the Accept header
  1315  	localVarHttpHeaderAccepts := []string{
  1316  		"application/json",
  1317  	}
  1318  
  1319  	// set Accept header
  1320  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1321  	if localVarHttpHeaderAccept != "" {
  1322  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1323  	}
  1324  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1325  	if err != nil {
  1326  		return successPayload, nil, err
  1327  	}
  1328  
  1329  	localVarHttpResponse, err := a.client.callAPI(r)
  1330  	if err != nil || localVarHttpResponse == nil {
  1331  		return successPayload, localVarHttpResponse, err
  1332  	}
  1333  	defer localVarHttpResponse.Body.Close()
  1334  	if localVarHttpResponse.StatusCode >= 300 {
  1335  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1336  	}
  1337  
  1338  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1339  		return successPayload, localVarHttpResponse, err
  1340  	}
  1341  
  1342  	return successPayload, localVarHttpResponse, err
  1343  }
  1344  
  1345  /* UpgradeApiService Get upgrade status for upgrade unit groups
  1346  Get upgrade status for upgrade unit groups
  1347  * @param ctx context.Context Authentication Context
  1348  @param optional (nil or map[string]interface{}) with one or more of:
  1349      @param "componentType" (string) Component type based on which upgrade unit groups to be filtered
  1350      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1351      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1352      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1353      @param "sortAscending" (bool)
  1354      @param "sortBy" (string) Field by which records are sorted
  1355  @return upgrade.UpgradeUnitGroupStatusListResult*/
  1356  func (a *UpgradeApiService) GetUpgradeUnitGroupsStatus(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupStatusListResult, *http.Response, error) {
  1357  	var (
  1358  		localVarHttpMethod = strings.ToUpper("Get")
  1359  		localVarPostBody   interface{}
  1360  		localVarFileName   string
  1361  		localVarFileBytes  []byte
  1362  		successPayload     upgrade.UpgradeUnitGroupStatusListResult
  1363  	)
  1364  
  1365  	// create path and map variables
  1366  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups-status"
  1367  
  1368  	localVarHeaderParams := make(map[string]string)
  1369  	localVarQueryParams := url.Values{}
  1370  	localVarFormParams := url.Values{}
  1371  
  1372  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
  1373  		return successPayload, nil, err
  1374  	}
  1375  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1376  		return successPayload, nil, err
  1377  	}
  1378  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1379  		return successPayload, nil, err
  1380  	}
  1381  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1382  		return successPayload, nil, err
  1383  	}
  1384  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1385  		return successPayload, nil, err
  1386  	}
  1387  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1388  		return successPayload, nil, err
  1389  	}
  1390  
  1391  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
  1392  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
  1393  	}
  1394  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1395  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1396  	}
  1397  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1398  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1399  	}
  1400  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1401  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1402  	}
  1403  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1404  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1405  	}
  1406  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1407  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1408  	}
  1409  	// to determine the Content-Type header
  1410  	localVarHttpContentTypes := []string{"application/json"}
  1411  
  1412  	// set Content-Type header
  1413  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1414  	if localVarHttpContentType != "" {
  1415  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1416  	}
  1417  
  1418  	// to determine the Accept header
  1419  	localVarHttpHeaderAccepts := []string{
  1420  		"application/json",
  1421  	}
  1422  
  1423  	// set Accept header
  1424  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1425  	if localVarHttpHeaderAccept != "" {
  1426  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1427  	}
  1428  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1429  	if err != nil {
  1430  		return successPayload, nil, err
  1431  	}
  1432  
  1433  	localVarHttpResponse, err := a.client.callAPI(r)
  1434  	if err != nil || localVarHttpResponse == nil {
  1435  		return successPayload, localVarHttpResponse, err
  1436  	}
  1437  	defer localVarHttpResponse.Body.Close()
  1438  	if localVarHttpResponse.StatusCode >= 300 {
  1439  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1440  	}
  1441  
  1442  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1443  		return successPayload, localVarHttpResponse, err
  1444  	}
  1445  
  1446  	return successPayload, localVarHttpResponse, err
  1447  }
  1448  
  1449  /* UpgradeApiService Get upgrade units
  1450  Get upgrade units
  1451  * @param ctx context.Context Authentication Context
  1452  @param optional (nil or map[string]interface{}) with one or more of:
  1453      @param "componentType" (string) Component type based on which upgrade units to be filtered
  1454      @param "currentVersion" (string) Current version of upgrade unit based on which upgrade units to be filtered
  1455      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1456      @param "groupId" (string) UUID of group based on which upgrade units to be filtered
  1457      @param "hasWarnings" (bool) Flag to indicate whether to return only upgrade units with warnings
  1458      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1459      @param "metadata" (string) Metadata about upgrade unit to filter on
  1460      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1461      @param "sortAscending" (bool)
  1462      @param "sortBy" (string) Field by which records are sorted
  1463      @param "upgradeUnitType" (string) Upgrade unit type based on which upgrade units to be filtered
  1464  @return UpgradeUnitListResult*/
  1465  func (a *UpgradeApiService) GetUpgradeUnits(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitListResult, *http.Response, error) {
  1466  	var (
  1467  		localVarHttpMethod = strings.ToUpper("Get")
  1468  		localVarPostBody   interface{}
  1469  		localVarFileName   string
  1470  		localVarFileBytes  []byte
  1471  		successPayload     upgrade.UpgradeUnitListResult
  1472  	)
  1473  
  1474  	// create path and map variables
  1475  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units"
  1476  
  1477  	localVarHeaderParams := make(map[string]string)
  1478  	localVarQueryParams := url.Values{}
  1479  	localVarFormParams := url.Values{}
  1480  
  1481  	if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil {
  1482  		return successPayload, nil, err
  1483  	}
  1484  	if err := typeCheckParameter(localVarOptionals["currentVersion"], "string", "currentVersion"); err != nil {
  1485  		return successPayload, nil, err
  1486  	}
  1487  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1488  		return successPayload, nil, err
  1489  	}
  1490  	if err := typeCheckParameter(localVarOptionals["groupId"], "string", "groupId"); err != nil {
  1491  		return successPayload, nil, err
  1492  	}
  1493  	if err := typeCheckParameter(localVarOptionals["hasWarnings"], "bool", "hasWarnings"); err != nil {
  1494  		return successPayload, nil, err
  1495  	}
  1496  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1497  		return successPayload, nil, err
  1498  	}
  1499  	if err := typeCheckParameter(localVarOptionals["metadata"], "string", "metadata"); err != nil {
  1500  		return successPayload, nil, err
  1501  	}
  1502  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1503  		return successPayload, nil, err
  1504  	}
  1505  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1506  		return successPayload, nil, err
  1507  	}
  1508  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1509  		return successPayload, nil, err
  1510  	}
  1511  	if err := typeCheckParameter(localVarOptionals["upgradeUnitType"], "string", "upgradeUnitType"); err != nil {
  1512  		return successPayload, nil, err
  1513  	}
  1514  
  1515  	if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk {
  1516  		localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, ""))
  1517  	}
  1518  	if localVarTempParam, localVarOk := localVarOptionals["currentVersion"].(string); localVarOk {
  1519  		localVarQueryParams.Add("current_version", parameterToString(localVarTempParam, ""))
  1520  	}
  1521  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1522  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1523  	}
  1524  	if localVarTempParam, localVarOk := localVarOptionals["groupId"].(string); localVarOk {
  1525  		localVarQueryParams.Add("group_id", parameterToString(localVarTempParam, ""))
  1526  	}
  1527  	if localVarTempParam, localVarOk := localVarOptionals["hasWarnings"].(bool); localVarOk {
  1528  		localVarQueryParams.Add("has_warnings", parameterToString(localVarTempParam, ""))
  1529  	}
  1530  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1531  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1532  	}
  1533  	if localVarTempParam, localVarOk := localVarOptionals["metadata"].(string); localVarOk {
  1534  		localVarQueryParams.Add("metadata", parameterToString(localVarTempParam, ""))
  1535  	}
  1536  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1537  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1538  	}
  1539  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1540  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1541  	}
  1542  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1543  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1544  	}
  1545  	if localVarTempParam, localVarOk := localVarOptionals["upgradeUnitType"].(string); localVarOk {
  1546  		localVarQueryParams.Add("upgrade_unit_type", parameterToString(localVarTempParam, ""))
  1547  	}
  1548  	// to determine the Content-Type header
  1549  	localVarHttpContentTypes := []string{"application/json"}
  1550  
  1551  	// set Content-Type header
  1552  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1553  	if localVarHttpContentType != "" {
  1554  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1555  	}
  1556  
  1557  	// to determine the Accept header
  1558  	localVarHttpHeaderAccepts := []string{
  1559  		"application/json",
  1560  	}
  1561  
  1562  	// set Accept header
  1563  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1564  	if localVarHttpHeaderAccept != "" {
  1565  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1566  	}
  1567  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1568  	if err != nil {
  1569  		return successPayload, nil, err
  1570  	}
  1571  
  1572  	localVarHttpResponse, err := a.client.callAPI(r)
  1573  	if err != nil || localVarHttpResponse == nil {
  1574  		return successPayload, localVarHttpResponse, err
  1575  	}
  1576  	defer localVarHttpResponse.Body.Close()
  1577  	if localVarHttpResponse.StatusCode >= 300 {
  1578  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1579  	}
  1580  
  1581  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1582  		return successPayload, localVarHttpResponse, err
  1583  	}
  1584  
  1585  	return successPayload, localVarHttpResponse, err
  1586  }
  1587  
  1588  /* UpgradeApiService Get upgrade units stats
  1589  Get upgrade units stats
  1590  * @param ctx context.Context Authentication Context
  1591  @param optional (nil or map[string]interface{}) with one or more of:
  1592      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1593      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1594      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1595      @param "sortAscending" (bool)
  1596      @param "sortBy" (string) Field by which records are sorted
  1597      @param "sync" (bool) Synchronize before returning upgrade unit stats
  1598  @return UpgradeUnitTypeStatsList*/
  1599  func (a *UpgradeApiService) GetUpgradeUnitsStats(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitTypeStatsList, *http.Response, error) {
  1600  	var (
  1601  		localVarHttpMethod = strings.ToUpper("Get")
  1602  		localVarPostBody   interface{}
  1603  		localVarFileName   string
  1604  		localVarFileBytes  []byte
  1605  		successPayload     upgrade.UpgradeUnitTypeStatsList
  1606  	)
  1607  
  1608  	// create path and map variables
  1609  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units-stats"
  1610  
  1611  	localVarHeaderParams := make(map[string]string)
  1612  	localVarQueryParams := url.Values{}
  1613  	localVarFormParams := url.Values{}
  1614  
  1615  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1616  		return successPayload, nil, err
  1617  	}
  1618  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1619  		return successPayload, nil, err
  1620  	}
  1621  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1622  		return successPayload, nil, err
  1623  	}
  1624  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1625  		return successPayload, nil, err
  1626  	}
  1627  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1628  		return successPayload, nil, err
  1629  	}
  1630  	if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil {
  1631  		return successPayload, nil, err
  1632  	}
  1633  
  1634  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1635  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1636  	}
  1637  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1638  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1639  	}
  1640  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1641  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1642  	}
  1643  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1644  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1645  	}
  1646  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1647  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1648  	}
  1649  	if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk {
  1650  		localVarQueryParams.Add("sync", parameterToString(localVarTempParam, ""))
  1651  	}
  1652  	// to determine the Content-Type header
  1653  	localVarHttpContentTypes := []string{"application/json"}
  1654  
  1655  	// set Content-Type header
  1656  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1657  	if localVarHttpContentType != "" {
  1658  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1659  	}
  1660  
  1661  	// to determine the Accept header
  1662  	localVarHttpHeaderAccepts := []string{
  1663  		"application/json",
  1664  	}
  1665  
  1666  	// set Accept header
  1667  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1668  	if localVarHttpHeaderAccept != "" {
  1669  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1670  	}
  1671  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1672  	if err != nil {
  1673  		return successPayload, nil, err
  1674  	}
  1675  
  1676  	localVarHttpResponse, err := a.client.callAPI(r)
  1677  	if err != nil || localVarHttpResponse == nil {
  1678  		return successPayload, localVarHttpResponse, err
  1679  	}
  1680  	defer localVarHttpResponse.Body.Close()
  1681  	if localVarHttpResponse.StatusCode >= 300 {
  1682  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1683  	}
  1684  
  1685  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1686  		return successPayload, localVarHttpResponse, err
  1687  	}
  1688  
  1689  	return successPayload, localVarHttpResponse, err
  1690  }
  1691  
  1692  /* UpgradeApiService Get the version whitelist
  1693  Get whitelist of versions for different components
  1694  * @param ctx context.Context Authentication Context
  1695  @return manager.AcceptableComponentVersionList*/
  1696  func (a *UpgradeApiService) GetVersionWhitelist(ctx context.Context) (upgrade.AcceptableComponentVersionList, *http.Response, error) {
  1697  	var (
  1698  		localVarHttpMethod = strings.ToUpper("Get")
  1699  		localVarPostBody   interface{}
  1700  		localVarFileName   string
  1701  		localVarFileBytes  []byte
  1702  		successPayload     upgrade.AcceptableComponentVersionList
  1703  	)
  1704  
  1705  	// create path and map variables
  1706  	localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist"
  1707  
  1708  	localVarHeaderParams := make(map[string]string)
  1709  	localVarQueryParams := url.Values{}
  1710  	localVarFormParams := url.Values{}
  1711  
  1712  	// to determine the Content-Type header
  1713  	localVarHttpContentTypes := []string{"application/json"}
  1714  
  1715  	// set Content-Type header
  1716  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1717  	if localVarHttpContentType != "" {
  1718  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1719  	}
  1720  
  1721  	// to determine the Accept header
  1722  	localVarHttpHeaderAccepts := []string{
  1723  		"application/json",
  1724  	}
  1725  
  1726  	// set Accept header
  1727  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1728  	if localVarHttpHeaderAccept != "" {
  1729  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1730  	}
  1731  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1732  	if err != nil {
  1733  		return successPayload, nil, err
  1734  	}
  1735  
  1736  	localVarHttpResponse, err := a.client.callAPI(r)
  1737  	if err != nil || localVarHttpResponse == nil {
  1738  		return successPayload, localVarHttpResponse, err
  1739  	}
  1740  	defer localVarHttpResponse.Body.Close()
  1741  	if localVarHttpResponse.StatusCode >= 300 {
  1742  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1743  	}
  1744  
  1745  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1746  		return successPayload, localVarHttpResponse, err
  1747  	}
  1748  
  1749  	return successPayload, localVarHttpResponse, err
  1750  }
  1751  
  1752  /* UpgradeApiService Get the version whitelist for the specified component
  1753  Get whitelist of versions for a component. Component can include HOST, EDGE, CCP, MP
  1754  * @param ctx context.Context Authentication Context
  1755  @param componentType
  1756  @return upgrade.AcceptableComponentVersion*/
  1757  func (a *UpgradeApiService) GetVersionWhitelistByComponent(ctx context.Context, componentType string) (upgrade.AcceptableComponentVersion, *http.Response, error) {
  1758  	var (
  1759  		localVarHttpMethod = strings.ToUpper("Get")
  1760  		localVarPostBody   interface{}
  1761  		localVarFileName   string
  1762  		localVarFileBytes  []byte
  1763  		successPayload     upgrade.AcceptableComponentVersion
  1764  	)
  1765  
  1766  	// create path and map variables
  1767  	localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist/{component_type}"
  1768  	localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1)
  1769  
  1770  	localVarHeaderParams := make(map[string]string)
  1771  	localVarQueryParams := url.Values{}
  1772  	localVarFormParams := url.Values{}
  1773  
  1774  	// to determine the Content-Type header
  1775  	localVarHttpContentTypes := []string{"application/json"}
  1776  
  1777  	// set Content-Type header
  1778  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1779  	if localVarHttpContentType != "" {
  1780  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1781  	}
  1782  
  1783  	// to determine the Accept header
  1784  	localVarHttpHeaderAccepts := []string{
  1785  		"application/json",
  1786  	}
  1787  
  1788  	// set Accept header
  1789  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1790  	if localVarHttpHeaderAccept != "" {
  1791  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1792  	}
  1793  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1794  	if err != nil {
  1795  		return successPayload, nil, err
  1796  	}
  1797  
  1798  	localVarHttpResponse, err := a.client.callAPI(r)
  1799  	if err != nil || localVarHttpResponse == nil {
  1800  		return successPayload, localVarHttpResponse, err
  1801  	}
  1802  	defer localVarHttpResponse.Body.Close()
  1803  	if localVarHttpResponse.StatusCode >= 300 {
  1804  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1805  	}
  1806  
  1807  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1808  		return successPayload, localVarHttpResponse, err
  1809  	}
  1810  
  1811  	return successPayload, localVarHttpResponse, err
  1812  }
  1813  
  1814  /* UpgradeApiService Pause upgrade
  1815  Pause upgrade
  1816  * @param ctx context.Context Authentication Context
  1817  @return */
  1818  func (a *UpgradeApiService) PauseUpgradePause(ctx context.Context) (*http.Response, error) {
  1819  	var (
  1820  		localVarHttpMethod = strings.ToUpper("Post")
  1821  		localVarPostBody   interface{}
  1822  		localVarFileName   string
  1823  		localVarFileBytes  []byte
  1824  	)
  1825  
  1826  	// create path and map variables
  1827  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=pause"
  1828  
  1829  	localVarHeaderParams := make(map[string]string)
  1830  	localVarQueryParams := url.Values{}
  1831  	localVarFormParams := url.Values{}
  1832  
  1833  	// to determine the Content-Type header
  1834  	localVarHttpContentTypes := []string{"application/json"}
  1835  
  1836  	// set Content-Type header
  1837  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1838  	if localVarHttpContentType != "" {
  1839  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1840  	}
  1841  
  1842  	// to determine the Accept header
  1843  	localVarHttpHeaderAccepts := []string{
  1844  		"application/json",
  1845  	}
  1846  
  1847  	// set Accept header
  1848  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1849  	if localVarHttpHeaderAccept != "" {
  1850  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1851  	}
  1852  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1853  	if err != nil {
  1854  		return nil, err
  1855  	}
  1856  
  1857  	localVarHttpResponse, err := a.client.callAPI(r)
  1858  	if err != nil || localVarHttpResponse == nil {
  1859  		return localVarHttpResponse, err
  1860  	}
  1861  	defer localVarHttpResponse.Body.Close()
  1862  	if localVarHttpResponse.StatusCode >= 300 {
  1863  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1864  	}
  1865  
  1866  	return localVarHttpResponse, err
  1867  }
  1868  
  1869  /* UpgradeApiService Reorder upgrade unit group
  1870  Reorder upgrade unit group
  1871  * @param ctx context.Context Authentication Context
  1872  @param groupId
  1873  @param reorderRequest
  1874  @return */
  1875  func (a *UpgradeApiService) ReorderUpgradeUnitGroupReorder(ctx context.Context, groupId string, reorderRequest upgrade.ReorderRequest) (*http.Response, error) {
  1876  	var (
  1877  		localVarHttpMethod = strings.ToUpper("Post")
  1878  		localVarPostBody   interface{}
  1879  		localVarFileName   string
  1880  		localVarFileBytes  []byte
  1881  	)
  1882  
  1883  	// create path and map variables
  1884  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}?action=reorder"
  1885  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
  1886  
  1887  	localVarHeaderParams := make(map[string]string)
  1888  	localVarQueryParams := url.Values{}
  1889  	localVarFormParams := url.Values{}
  1890  
  1891  	// to determine the Content-Type header
  1892  	localVarHttpContentTypes := []string{"application/json"}
  1893  
  1894  	// set Content-Type header
  1895  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1896  	if localVarHttpContentType != "" {
  1897  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1898  	}
  1899  
  1900  	// to determine the Accept header
  1901  	localVarHttpHeaderAccepts := []string{
  1902  		"application/json",
  1903  	}
  1904  
  1905  	// set Accept header
  1906  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1907  	if localVarHttpHeaderAccept != "" {
  1908  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1909  	}
  1910  	// body params
  1911  	localVarPostBody = &reorderRequest
  1912  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1913  	if err != nil {
  1914  		return nil, err
  1915  	}
  1916  
  1917  	localVarHttpResponse, err := a.client.callAPI(r)
  1918  	if err != nil || localVarHttpResponse == nil {
  1919  		return localVarHttpResponse, err
  1920  	}
  1921  	defer localVarHttpResponse.Body.Close()
  1922  	if localVarHttpResponse.StatusCode >= 300 {
  1923  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1924  	}
  1925  
  1926  	return localVarHttpResponse, err
  1927  }
  1928  
  1929  /* UpgradeApiService Reorder an upgrade unit within the upgrade unit group
  1930  Reorder an upgrade unit within the upgrade unit group
  1931  * @param ctx context.Context Authentication Context
  1932  @param groupId
  1933  @param upgradeUnitId
  1934  @param reorderRequest
  1935  @return */
  1936  func (a *UpgradeApiService) ReorderUpgradeUnitReorder(ctx context.Context, groupId string, upgradeUnitId string, reorderRequest upgrade.ReorderRequest) (*http.Response, error) {
  1937  	var (
  1938  		localVarHttpMethod = strings.ToUpper("Post")
  1939  		localVarPostBody   interface{}
  1940  		localVarFileName   string
  1941  		localVarFileBytes  []byte
  1942  	)
  1943  
  1944  	// create path and map variables
  1945  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}/upgrade-unit/{upgrade-unit-id}?action=reorder"
  1946  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
  1947  	localVarPath = strings.Replace(localVarPath, "{"+"upgrade-unit-id"+"}", fmt.Sprintf("%v", upgradeUnitId), -1)
  1948  
  1949  	localVarHeaderParams := make(map[string]string)
  1950  	localVarQueryParams := url.Values{}
  1951  	localVarFormParams := url.Values{}
  1952  
  1953  	// to determine the Content-Type header
  1954  	localVarHttpContentTypes := []string{"application/json"}
  1955  
  1956  	// set Content-Type header
  1957  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1958  	if localVarHttpContentType != "" {
  1959  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1960  	}
  1961  
  1962  	// to determine the Accept header
  1963  	localVarHttpHeaderAccepts := []string{
  1964  		"application/json",
  1965  	}
  1966  
  1967  	// set Accept header
  1968  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1969  	if localVarHttpHeaderAccept != "" {
  1970  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1971  	}
  1972  	// body params
  1973  	localVarPostBody = &reorderRequest
  1974  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1975  	if err != nil {
  1976  		return nil, err
  1977  	}
  1978  
  1979  	localVarHttpResponse, err := a.client.callAPI(r)
  1980  	if err != nil || localVarHttpResponse == nil {
  1981  		return localVarHttpResponse, err
  1982  	}
  1983  	defer localVarHttpResponse.Body.Close()
  1984  	if localVarHttpResponse.StatusCode >= 300 {
  1985  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1986  	}
  1987  
  1988  	return localVarHttpResponse, err
  1989  }
  1990  
  1991  /* UpgradeApiService Reset upgrade plan to default plan
  1992  Reset the upgrade plan to default plan. User has an option to change the default plan. But if after making changes, user wants to go back to the default plan, this is the way to do so.
  1993  * @param ctx context.Context Authentication Context
  1994  @param componentType Component type
  1995  @return */
  1996  func (a *UpgradeApiService) ResetUpgradePlanReset(ctx context.Context, componentType string) (*http.Response, error) {
  1997  	var (
  1998  		localVarHttpMethod = strings.ToUpper("Post")
  1999  		localVarPostBody   interface{}
  2000  		localVarFileName   string
  2001  		localVarFileBytes  []byte
  2002  	)
  2003  
  2004  	// create path and map variables
  2005  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=reset"
  2006  
  2007  	localVarHeaderParams := make(map[string]string)
  2008  	localVarQueryParams := url.Values{}
  2009  	localVarFormParams := url.Values{}
  2010  
  2011  	localVarQueryParams.Add("component_type", parameterToString(componentType, ""))
  2012  	// to determine the Content-Type header
  2013  	localVarHttpContentTypes := []string{"application/json"}
  2014  
  2015  	// set Content-Type header
  2016  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2017  	if localVarHttpContentType != "" {
  2018  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2019  	}
  2020  
  2021  	// to determine the Accept header
  2022  	localVarHttpHeaderAccepts := []string{
  2023  		"application/json",
  2024  	}
  2025  
  2026  	// set Accept header
  2027  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2028  	if localVarHttpHeaderAccept != "" {
  2029  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2030  	}
  2031  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2032  	if err != nil {
  2033  		return nil, err
  2034  	}
  2035  
  2036  	localVarHttpResponse, err := a.client.callAPI(r)
  2037  	if err != nil || localVarHttpResponse == nil {
  2038  		return localVarHttpResponse, err
  2039  	}
  2040  	defer localVarHttpResponse.Body.Close()
  2041  	if localVarHttpResponse.StatusCode >= 300 {
  2042  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2043  	}
  2044  
  2045  	return localVarHttpResponse, err
  2046  }
  2047  
  2048  /* UpgradeApiService Start upgrade
  2049  Start upgrade
  2050  * @param ctx context.Context Authentication Context
  2051  @return */
  2052  func (a *UpgradeApiService) StartUpgradeStart(ctx context.Context) (*http.Response, error) {
  2053  	var (
  2054  		localVarHttpMethod = strings.ToUpper("Post")
  2055  		localVarPostBody   interface{}
  2056  		localVarFileName   string
  2057  		localVarFileBytes  []byte
  2058  	)
  2059  
  2060  	// create path and map variables
  2061  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=start"
  2062  
  2063  	localVarHeaderParams := make(map[string]string)
  2064  	localVarQueryParams := url.Values{}
  2065  	localVarFormParams := url.Values{}
  2066  
  2067  	// to determine the Content-Type header
  2068  	localVarHttpContentTypes := []string{"application/json"}
  2069  
  2070  	// set Content-Type header
  2071  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2072  	if localVarHttpContentType != "" {
  2073  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2074  	}
  2075  
  2076  	// to determine the Accept header
  2077  	localVarHttpHeaderAccepts := []string{
  2078  		"application/json",
  2079  	}
  2080  
  2081  	// set Accept header
  2082  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2083  	if localVarHttpHeaderAccept != "" {
  2084  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2085  	}
  2086  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2087  	if err != nil {
  2088  		return nil, err
  2089  	}
  2090  
  2091  	localVarHttpResponse, err := a.client.callAPI(r)
  2092  	if err != nil || localVarHttpResponse == nil {
  2093  		return localVarHttpResponse, err
  2094  	}
  2095  	defer localVarHttpResponse.Body.Close()
  2096  	if localVarHttpResponse.StatusCode >= 300 {
  2097  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2098  	}
  2099  
  2100  	return localVarHttpResponse, err
  2101  }
  2102  
  2103  /* UpgradeApiService Upgrade the upgrade coordinator.
  2104  Upgrade the upgrade coordinator.
  2105  * @param ctx context.Context Authentication Context
  2106  @return */
  2107  func (a *UpgradeApiService) TriggerUcUpgradeUpgradeUc(ctx context.Context) (*http.Response, error) {
  2108  	var (
  2109  		localVarHttpMethod = strings.ToUpper("Post")
  2110  		localVarPostBody   interface{}
  2111  		localVarFileName   string
  2112  		localVarFileBytes  []byte
  2113  	)
  2114  
  2115  	// create path and map variables
  2116  	localVarPath := a.client.cfg.BasePath + "/upgrade?action=upgrade_uc"
  2117  
  2118  	localVarHeaderParams := make(map[string]string)
  2119  	localVarQueryParams := url.Values{}
  2120  	localVarFormParams := url.Values{}
  2121  
  2122  	// to determine the Content-Type header
  2123  	localVarHttpContentTypes := []string{"application/json"}
  2124  
  2125  	// set Content-Type header
  2126  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2127  	if localVarHttpContentType != "" {
  2128  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2129  	}
  2130  
  2131  	// to determine the Accept header
  2132  	localVarHttpHeaderAccepts := []string{
  2133  		"application/json",
  2134  	}
  2135  
  2136  	// set Accept header
  2137  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2138  	if localVarHttpHeaderAccept != "" {
  2139  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2140  	}
  2141  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2142  	if err != nil {
  2143  		return nil, err
  2144  	}
  2145  
  2146  	localVarHttpResponse, err := a.client.callAPI(r)
  2147  	if err != nil || localVarHttpResponse == nil {
  2148  		return localVarHttpResponse, err
  2149  	}
  2150  	defer localVarHttpResponse.Body.Close()
  2151  	if localVarHttpResponse.StatusCode >= 300 {
  2152  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2153  	}
  2154  
  2155  	return localVarHttpResponse, err
  2156  }
  2157  
  2158  /* UpgradeApiService Update upgrade plan settings for the component
  2159  Update the upgrade plan settings for the component.
  2160  * @param ctx context.Context Authentication Context
  2161  @param componentType
  2162  @param upgradePlanSettings
  2163  @return UpgradePlanSettings*/
  2164  func (a *UpgradeApiService) UpdateUpgradePlanSettings(ctx context.Context, componentType string, upgradePlanSettings upgrade.UpgradePlanSettings) (upgrade.UpgradePlanSettings, *http.Response, error) {
  2165  	var (
  2166  		localVarHttpMethod = strings.ToUpper("Put")
  2167  		localVarPostBody   interface{}
  2168  		localVarFileName   string
  2169  		localVarFileBytes  []byte
  2170  		successPayload     upgrade.UpgradePlanSettings
  2171  	)
  2172  
  2173  	// create path and map variables
  2174  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan/{component_type}/settings"
  2175  	localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1)
  2176  
  2177  	localVarHeaderParams := make(map[string]string)
  2178  	localVarQueryParams := url.Values{}
  2179  	localVarFormParams := url.Values{}
  2180  
  2181  	// to determine the Content-Type header
  2182  	localVarHttpContentTypes := []string{"application/json"}
  2183  
  2184  	// set Content-Type header
  2185  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2186  	if localVarHttpContentType != "" {
  2187  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2188  	}
  2189  
  2190  	// to determine the Accept header
  2191  	localVarHttpHeaderAccepts := []string{
  2192  		"application/json",
  2193  	}
  2194  
  2195  	// set Accept header
  2196  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2197  	if localVarHttpHeaderAccept != "" {
  2198  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2199  	}
  2200  	// body params
  2201  	localVarPostBody = &upgradePlanSettings
  2202  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2203  	if err != nil {
  2204  		return successPayload, nil, err
  2205  	}
  2206  
  2207  	localVarHttpResponse, err := a.client.callAPI(r)
  2208  	if err != nil || localVarHttpResponse == nil {
  2209  		return successPayload, localVarHttpResponse, err
  2210  	}
  2211  	defer localVarHttpResponse.Body.Close()
  2212  	if localVarHttpResponse.StatusCode >= 300 {
  2213  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2214  	}
  2215  
  2216  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2217  		return successPayload, localVarHttpResponse, err
  2218  	}
  2219  
  2220  	return successPayload, localVarHttpResponse, err
  2221  }
  2222  
  2223  /* UpgradeApiService Update the upgrade unit group
  2224  Update the upgrade unit group
  2225  * @param ctx context.Context Authentication Context
  2226  @param groupId
  2227  @param upgradeUnitGroup
  2228  @return upgrade.UpgradeUnitGroup*/
  2229  func (a *UpgradeApiService) UpdateUpgradeUnitGroup(ctx context.Context, groupId string, upgradeUnitGroup upgrade.UpgradeUnitGroup) (upgrade.UpgradeUnitGroup, *http.Response, error) {
  2230  	var (
  2231  		localVarHttpMethod = strings.ToUpper("Put")
  2232  		localVarPostBody   interface{}
  2233  		localVarFileName   string
  2234  		localVarFileBytes  []byte
  2235  		successPayload     upgrade.UpgradeUnitGroup
  2236  	)
  2237  
  2238  	// create path and map variables
  2239  	localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}"
  2240  	localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1)
  2241  
  2242  	localVarHeaderParams := make(map[string]string)
  2243  	localVarQueryParams := url.Values{}
  2244  	localVarFormParams := url.Values{}
  2245  
  2246  	// to determine the Content-Type header
  2247  	localVarHttpContentTypes := []string{"application/json"}
  2248  
  2249  	// set Content-Type header
  2250  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2251  	if localVarHttpContentType != "" {
  2252  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2253  	}
  2254  
  2255  	// to determine the Accept header
  2256  	localVarHttpHeaderAccepts := []string{
  2257  		"application/json",
  2258  	}
  2259  
  2260  	// set Accept header
  2261  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2262  	if localVarHttpHeaderAccept != "" {
  2263  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2264  	}
  2265  	// body params
  2266  	localVarPostBody = &upgradeUnitGroup
  2267  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2268  	if err != nil {
  2269  		return successPayload, nil, err
  2270  	}
  2271  
  2272  	localVarHttpResponse, err := a.client.callAPI(r)
  2273  	if err != nil || localVarHttpResponse == nil {
  2274  		return successPayload, localVarHttpResponse, err
  2275  	}
  2276  	defer localVarHttpResponse.Body.Close()
  2277  	if localVarHttpResponse.StatusCode >= 300 {
  2278  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2279  	}
  2280  
  2281  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2282  		return successPayload, localVarHttpResponse, err
  2283  	}
  2284  
  2285  	return successPayload, localVarHttpResponse, err
  2286  }
  2287  
  2288  /* UpgradeApiService Update the version whitelist for the specified component type
  2289  Update the version whitelist for the specified component type (HOST, EDGE, CCP, MP).
  2290  * @param ctx context.Context Authentication Context
  2291  @param componentType
  2292  @param versionList
  2293  @return */
  2294  func (a *UpgradeApiService) UpdateVersionWhitelist(ctx context.Context, componentType string, versionList upgrade.VersionList) (*http.Response, error) {
  2295  	var (
  2296  		localVarHttpMethod = strings.ToUpper("Put")
  2297  		localVarPostBody   interface{}
  2298  		localVarFileName   string
  2299  		localVarFileBytes  []byte
  2300  	)
  2301  
  2302  	// create path and map variables
  2303  	localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist/{component_type}"
  2304  	localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1)
  2305  
  2306  	localVarHeaderParams := make(map[string]string)
  2307  	localVarQueryParams := url.Values{}
  2308  	localVarFormParams := url.Values{}
  2309  
  2310  	// to determine the Content-Type header
  2311  	localVarHttpContentTypes := []string{"application/json"}
  2312  
  2313  	// set Content-Type header
  2314  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2315  	if localVarHttpContentType != "" {
  2316  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2317  	}
  2318  
  2319  	// to determine the Accept header
  2320  	localVarHttpHeaderAccepts := []string{
  2321  		"application/json",
  2322  	}
  2323  
  2324  	// set Accept header
  2325  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2326  	if localVarHttpHeaderAccept != "" {
  2327  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2328  	}
  2329  	// body params
  2330  	localVarPostBody = &versionList
  2331  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2332  	if err != nil {
  2333  		return nil, err
  2334  	}
  2335  
  2336  	localVarHttpResponse, err := a.client.callAPI(r)
  2337  	if err != nil || localVarHttpResponse == nil {
  2338  		return localVarHttpResponse, err
  2339  	}
  2340  	defer localVarHttpResponse.Body.Close()
  2341  	if localVarHttpResponse.StatusCode >= 300 {
  2342  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2343  	}
  2344  
  2345  	return localVarHttpResponse, err
  2346  }
  2347  
  2348  /* UpgradeApiService Upgrade selected units
  2349  Upgrade selected units
  2350  * @param ctx context.Context Authentication Context
  2351  @param upgradeUnitList
  2352  @return */
  2353  func (a *UpgradeApiService) UpgradeSelectedUnitsUpgradeSelectedUnits(ctx context.Context, upgradeUnitList upgrade.UpgradeUnitList) (*http.Response, error) {
  2354  	var (
  2355  		localVarHttpMethod = strings.ToUpper("Post")
  2356  		localVarPostBody   interface{}
  2357  		localVarFileName   string
  2358  		localVarFileBytes  []byte
  2359  	)
  2360  
  2361  	// create path and map variables
  2362  	localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=upgrade_selected_units"
  2363  
  2364  	localVarHeaderParams := make(map[string]string)
  2365  	localVarQueryParams := url.Values{}
  2366  	localVarFormParams := url.Values{}
  2367  
  2368  	// to determine the Content-Type header
  2369  	localVarHttpContentTypes := []string{"application/json"}
  2370  
  2371  	// set Content-Type header
  2372  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2373  	if localVarHttpContentType != "" {
  2374  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2375  	}
  2376  
  2377  	// to determine the Accept header
  2378  	localVarHttpHeaderAccepts := []string{
  2379  		"application/json",
  2380  	}
  2381  
  2382  	// set Accept header
  2383  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2384  	if localVarHttpHeaderAccept != "" {
  2385  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2386  	}
  2387  	// body params
  2388  	localVarPostBody = &upgradeUnitList
  2389  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2390  	if err != nil {
  2391  		return nil, err
  2392  	}
  2393  
  2394  	localVarHttpResponse, err := a.client.callAPI(r)
  2395  	if err != nil || localVarHttpResponse == nil {
  2396  		return localVarHttpResponse, err
  2397  	}
  2398  	defer localVarHttpResponse.Body.Close()
  2399  	if localVarHttpResponse.StatusCode >= 300 {
  2400  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2401  	}
  2402  
  2403  	return localVarHttpResponse, err
  2404  }