github.com/vmware/go-vmware-nsxt@v0.0.0-20230223012718-d31b8a1ca05e/grouping_objects_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/manager"
    13  	"net/http"
    14  	"net/url"
    15  	"strings"
    16  )
    17  
    18  // Linger please
    19  var (
    20  	_ context.Context
    21  )
    22  
    23  type GroupingObjectsApiService service
    24  
    25  /* GroupingObjectsApiService Add a MAC address to a MACSet
    26  Add an individual MAC address to a MACSet
    27  * @param ctx context.Context Authentication Context
    28  @param macSetId MAC Set Id
    29  @param mACAddressElement
    30  @return manager.MacAddressElement*/
    31  func (a *GroupingObjectsApiService) AddMACAddress(ctx context.Context, macSetId string, mACAddressElement manager.MacAddressElement) (manager.MacAddressElement, *http.Response, error) {
    32  	var (
    33  		localVarHttpMethod = strings.ToUpper("Post")
    34  		localVarPostBody   interface{}
    35  		localVarFileName   string
    36  		localVarFileBytes  []byte
    37  		successPayload     manager.MacAddressElement
    38  	)
    39  
    40  	// create path and map variables
    41  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}/members"
    42  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -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 = &mACAddressElement
    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  /* GroupingObjectsApiService Add NSGroup expression
    91  Add/remove the expressions passed in the request body to/from the NSGroup
    92  * @param ctx context.Context Authentication Context
    93  @param nsGroupId NSGroup Id
    94  @param nSGroupExpressionList
    95  @param action Specifies addition or removal action
    96  @return NsGroup*/
    97  func (a *GroupingObjectsApiService) AddOrRemoveNSGroupExpression(ctx context.Context, nsGroupId string, nSGroupExpressionList manager.NsGroupExpressionList, action string) (manager.NsGroup, *http.Response, error) {
    98  	var (
    99  		localVarHttpMethod = strings.ToUpper("Post")
   100  		localVarPostBody   interface{}
   101  		localVarFileName   string
   102  		localVarFileBytes  []byte
   103  		successPayload     manager.NsGroup
   104  	)
   105  
   106  	// create path and map variables
   107  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
   108  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
   109  
   110  	localVarHeaderParams := make(map[string]string)
   111  	localVarQueryParams := url.Values{}
   112  	localVarFormParams := url.Values{}
   113  
   114  	localVarQueryParams.Add("action", parameterToString(action, ""))
   115  	// to determine the Content-Type header
   116  	localVarHttpContentTypes := []string{"application/json"}
   117  
   118  	// set Content-Type header
   119  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   120  	if localVarHttpContentType != "" {
   121  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   122  	}
   123  
   124  	// to determine the Accept header
   125  	localVarHttpHeaderAccepts := []string{
   126  		"application/json",
   127  	}
   128  
   129  	// set Accept header
   130  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   131  	if localVarHttpHeaderAccept != "" {
   132  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   133  	}
   134  	// body params
   135  	localVarPostBody = &nSGroupExpressionList
   136  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   137  	if err != nil {
   138  		return successPayload, nil, err
   139  	}
   140  
   141  	localVarHttpResponse, err := a.client.callAPI(r)
   142  	if err != nil || localVarHttpResponse == nil {
   143  		return successPayload, localVarHttpResponse, err
   144  	}
   145  	defer localVarHttpResponse.Body.Close()
   146  	if localVarHttpResponse.StatusCode >= 300 {
   147  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   148  	}
   149  
   150  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   151  		return successPayload, localVarHttpResponse, err
   152  	}
   153  
   154  	return successPayload, localVarHttpResponse, err
   155  }
   156  
   157  /* GroupingObjectsApiService Add NSGroup expression
   158  Add/remove the expressions passed in the request body to/from the NSGroup
   159  * @param ctx context.Context Authentication Context
   160  @param nsGroupId NSGroup Id
   161  @param nSGroupExpressionList
   162  @param action Specifies addition or removal action
   163  @return NsGroup*/
   164  func (a *GroupingObjectsApiService) AddOrRemoveNsGroupTagExpression(ctx context.Context, nsGroupId string, nSGroupExpressionList manager.NsGroupTagExpressionList, action string) (manager.NsGroup, *http.Response, error) {
   165  	var (
   166  		localVarHttpMethod = strings.ToUpper("Post")
   167  		localVarPostBody   interface{}
   168  		localVarFileName   string
   169  		localVarFileBytes  []byte
   170  		successPayload     manager.NsGroup
   171  	)
   172  
   173  	// create path and map variables
   174  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
   175  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
   176  
   177  	localVarHeaderParams := make(map[string]string)
   178  	localVarQueryParams := url.Values{}
   179  	localVarFormParams := url.Values{}
   180  
   181  	localVarQueryParams.Add("action", parameterToString(action, ""))
   182  	// to determine the Content-Type header
   183  	localVarHttpContentTypes := []string{"application/json"}
   184  
   185  	// set Content-Type header
   186  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   187  	if localVarHttpContentType != "" {
   188  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   189  	}
   190  
   191  	// to determine the Accept header
   192  	localVarHttpHeaderAccepts := []string{
   193  		"application/json",
   194  	}
   195  
   196  	// set Accept header
   197  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   198  	if localVarHttpHeaderAccept != "" {
   199  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   200  	}
   201  	// body params
   202  	localVarPostBody = &nSGroupExpressionList
   203  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   204  	if err != nil {
   205  		return successPayload, nil, err
   206  	}
   207  
   208  	localVarHttpResponse, err := a.client.callAPI(r)
   209  	if err != nil || localVarHttpResponse == nil {
   210  		return successPayload, localVarHttpResponse, err
   211  	}
   212  	defer localVarHttpResponse.Body.Close()
   213  	if localVarHttpResponse.StatusCode >= 300 {
   214  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   215  	}
   216  
   217  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   218  		return successPayload, localVarHttpResponse, err
   219  	}
   220  
   221  	return successPayload, localVarHttpResponse, err
   222  }
   223  
   224  /* GroupingObjectsApiService Add NSGroup expression
   225  Add/remove the expressions passed in the request body to/from the NSGroup
   226  * @param ctx context.Context Authentication Context
   227  @param nsGroupId NSGroup Id
   228  @param nSGroupExpressionList
   229  @param action Specifies addition or removal action
   230  @return NsGroup*/
   231  func (a *GroupingObjectsApiService) AddOrRemoveNsGroupSimpleExpression(ctx context.Context, nsGroupId string, nSGroupExpressionList manager.NsGroupSimpleExpressionList, action string) (manager.NsGroup, *http.Response, error) {
   232  	var (
   233  		localVarHttpMethod = strings.ToUpper("Post")
   234  		localVarPostBody   interface{}
   235  		localVarFileName   string
   236  		localVarFileBytes  []byte
   237  		successPayload     manager.NsGroup
   238  	)
   239  
   240  	// create path and map variables
   241  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
   242  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
   243  
   244  	localVarHeaderParams := make(map[string]string)
   245  	localVarQueryParams := url.Values{}
   246  	localVarFormParams := url.Values{}
   247  
   248  	localVarQueryParams.Add("action", parameterToString(action, ""))
   249  	// to determine the Content-Type header
   250  	localVarHttpContentTypes := []string{"application/json"}
   251  
   252  	// set Content-Type header
   253  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   254  	if localVarHttpContentType != "" {
   255  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   256  	}
   257  
   258  	// to determine the Accept header
   259  	localVarHttpHeaderAccepts := []string{
   260  		"application/json",
   261  	}
   262  
   263  	// set Accept header
   264  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   265  	if localVarHttpHeaderAccept != "" {
   266  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   267  	}
   268  	// body params
   269  	localVarPostBody = &nSGroupExpressionList
   270  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   271  	if err != nil {
   272  		return successPayload, nil, err
   273  	}
   274  
   275  	localVarHttpResponse, err := a.client.callAPI(r)
   276  	if err != nil || localVarHttpResponse == nil {
   277  		return successPayload, localVarHttpResponse, err
   278  	}
   279  	defer localVarHttpResponse.Body.Close()
   280  	if localVarHttpResponse.StatusCode >= 300 {
   281  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   282  	}
   283  
   284  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   285  		return successPayload, localVarHttpResponse, err
   286  	}
   287  
   288  	return successPayload, localVarHttpResponse, err
   289  }
   290  
   291  /* GroupingObjectsApiService Create IPSet
   292  Creates a new IPSet that can group either IPv4 or IPv6 individual ip addresses, ranges or subnets.
   293  * @param ctx context.Context Authentication Context
   294  @param iPSet
   295  @return manager.IpSet*/
   296  func (a *GroupingObjectsApiService) CreateIPSet(ctx context.Context, iPSet manager.IpSet) (manager.IpSet, *http.Response, error) {
   297  	var (
   298  		localVarHttpMethod = strings.ToUpper("Post")
   299  		localVarPostBody   interface{}
   300  		localVarFileName   string
   301  		localVarFileBytes  []byte
   302  		successPayload     manager.IpSet
   303  	)
   304  
   305  	// create path and map variables
   306  	localVarPath := a.client.cfg.BasePath + "/ip-sets"
   307  
   308  	localVarHeaderParams := make(map[string]string)
   309  	localVarQueryParams := url.Values{}
   310  	localVarFormParams := url.Values{}
   311  
   312  	// to determine the Content-Type header
   313  	localVarHttpContentTypes := []string{"application/json"}
   314  
   315  	// set Content-Type header
   316  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   317  	if localVarHttpContentType != "" {
   318  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   319  	}
   320  
   321  	// to determine the Accept header
   322  	localVarHttpHeaderAccepts := []string{
   323  		"application/json",
   324  	}
   325  
   326  	// set Accept header
   327  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   328  	if localVarHttpHeaderAccept != "" {
   329  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   330  	}
   331  	// body params
   332  	localVarPostBody = &iPSet
   333  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   334  	if err != nil {
   335  		return successPayload, nil, err
   336  	}
   337  
   338  	localVarHttpResponse, err := a.client.callAPI(r)
   339  	if err != nil || localVarHttpResponse == nil {
   340  		return successPayload, localVarHttpResponse, err
   341  	}
   342  	defer localVarHttpResponse.Body.Close()
   343  	if localVarHttpResponse.StatusCode >= 300 {
   344  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   345  	}
   346  
   347  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   348  		return successPayload, localVarHttpResponse, err
   349  	}
   350  
   351  	return successPayload, localVarHttpResponse, err
   352  }
   353  
   354  /* GroupingObjectsApiService Create MACSet
   355  Creates a new MACSet that can group individual MAC addresses.
   356  * @param ctx context.Context Authentication Context
   357  @param mACSet
   358  @return manager.MacSet*/
   359  func (a *GroupingObjectsApiService) CreateMACSet(ctx context.Context, mACSet manager.MacSet) (manager.MacSet, *http.Response, error) {
   360  	var (
   361  		localVarHttpMethod = strings.ToUpper("Post")
   362  		localVarPostBody   interface{}
   363  		localVarFileName   string
   364  		localVarFileBytes  []byte
   365  		successPayload     manager.MacSet
   366  	)
   367  
   368  	// create path and map variables
   369  	localVarPath := a.client.cfg.BasePath + "/mac-sets"
   370  
   371  	localVarHeaderParams := make(map[string]string)
   372  	localVarQueryParams := url.Values{}
   373  	localVarFormParams := url.Values{}
   374  
   375  	// to determine the Content-Type header
   376  	localVarHttpContentTypes := []string{"application/json"}
   377  
   378  	// set Content-Type header
   379  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   380  	if localVarHttpContentType != "" {
   381  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   382  	}
   383  
   384  	// to determine the Accept header
   385  	localVarHttpHeaderAccepts := []string{
   386  		"application/json",
   387  	}
   388  
   389  	// set Accept header
   390  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   391  	if localVarHttpHeaderAccept != "" {
   392  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   393  	}
   394  	// body params
   395  	localVarPostBody = &mACSet
   396  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   397  	if err != nil {
   398  		return successPayload, nil, err
   399  	}
   400  
   401  	localVarHttpResponse, err := a.client.callAPI(r)
   402  	if err != nil || localVarHttpResponse == nil {
   403  		return successPayload, localVarHttpResponse, err
   404  	}
   405  	defer localVarHttpResponse.Body.Close()
   406  	if localVarHttpResponse.StatusCode >= 300 {
   407  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   408  	}
   409  
   410  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   411  		return successPayload, localVarHttpResponse, err
   412  	}
   413  
   414  	return successPayload, localVarHttpResponse, err
   415  }
   416  
   417  /* GroupingObjectsApiService Create NSGroup
   418  Creates a new NSGroup that can group NSX resources - VIFs, Lports and LSwitches as well as the grouping objects - IPSet, MACSet and other NSGroups
   419  * @param ctx context.Context Authentication Context
   420  @param nSGroup
   421  @return NsGroup*/
   422  func (a *GroupingObjectsApiService) CreateNSGroup(ctx context.Context, nSGroup manager.NsGroup) (manager.NsGroup, *http.Response, error) {
   423  	var (
   424  		localVarHttpMethod = strings.ToUpper("Post")
   425  		localVarPostBody   interface{}
   426  		localVarFileName   string
   427  		localVarFileBytes  []byte
   428  		successPayload     manager.NsGroup
   429  	)
   430  
   431  	// create path and map variables
   432  	localVarPath := a.client.cfg.BasePath + "/ns-groups"
   433  
   434  	localVarHeaderParams := make(map[string]string)
   435  	localVarQueryParams := url.Values{}
   436  	localVarFormParams := url.Values{}
   437  
   438  	// to determine the Content-Type header
   439  	localVarHttpContentTypes := []string{"application/json"}
   440  
   441  	// set Content-Type header
   442  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   443  	if localVarHttpContentType != "" {
   444  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   445  	}
   446  
   447  	// to determine the Accept header
   448  	localVarHttpHeaderAccepts := []string{
   449  		"application/json",
   450  	}
   451  
   452  	// set Accept header
   453  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   454  	if localVarHttpHeaderAccept != "" {
   455  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   456  	}
   457  	// body params
   458  	localVarPostBody = &nSGroup
   459  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   460  	if err != nil {
   461  		return successPayload, nil, err
   462  	}
   463  
   464  	localVarHttpResponse, err := a.client.callAPI(r)
   465  	if err != nil || localVarHttpResponse == nil {
   466  		return successPayload, localVarHttpResponse, err
   467  	}
   468  	defer localVarHttpResponse.Body.Close()
   469  	if localVarHttpResponse.StatusCode >= 300 {
   470  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   471  	}
   472  
   473  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   474  		return successPayload, localVarHttpResponse, err
   475  	}
   476  
   477  	return successPayload, localVarHttpResponse, err
   478  }
   479  
   480  /* GroupingObjectsApiService Create NSService
   481  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   482  * @param ctx context.Context Authentication Context
   483  @param nSService
   484  @return manager.NsService*/
   485  func (a *GroupingObjectsApiService) CreateNSService(ctx context.Context, nSService manager.NsService) (manager.NsService, *http.Response, error) {
   486  	var (
   487  		localVarHttpMethod = strings.ToUpper("Post")
   488  		localVarPostBody   interface{}
   489  		localVarFileName   string
   490  		localVarFileBytes  []byte
   491  		successPayload     manager.NsService
   492  	)
   493  
   494  	// create path and map variables
   495  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   496  
   497  	localVarHeaderParams := make(map[string]string)
   498  	localVarQueryParams := url.Values{}
   499  	localVarFormParams := url.Values{}
   500  
   501  	// to determine the Content-Type header
   502  	localVarHttpContentTypes := []string{"application/json"}
   503  
   504  	// set Content-Type header
   505  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   506  	if localVarHttpContentType != "" {
   507  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   508  	}
   509  
   510  	// to determine the Accept header
   511  	localVarHttpHeaderAccepts := []string{
   512  		"application/json",
   513  	}
   514  
   515  	// set Accept header
   516  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   517  	if localVarHttpHeaderAccept != "" {
   518  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   519  	}
   520  	// body params
   521  	localVarPostBody = &nSService
   522  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   523  	if err != nil {
   524  		return successPayload, nil, err
   525  	}
   526  
   527  	localVarHttpResponse, err := a.client.callAPI(r)
   528  	if err != nil || localVarHttpResponse == nil {
   529  		return successPayload, localVarHttpResponse, err
   530  	}
   531  	defer localVarHttpResponse.Body.Close()
   532  	if localVarHttpResponse.StatusCode >= 300 {
   533  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   534  	}
   535  
   536  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   537  		return successPayload, localVarHttpResponse, err
   538  	}
   539  
   540  	return successPayload, localVarHttpResponse, err
   541  }
   542  
   543  /* GroupingObjectsApiService Create L4PortSetNSService
   544  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   545  * @param ctx context.Context Authentication Context
   546  @param nSService
   547  @return manager.NsService*/
   548  func (a *GroupingObjectsApiService) CreateL4PortSetNSService(ctx context.Context, nSService manager.L4PortSetNsService) (manager.L4PortSetNsService, *http.Response, error) {
   549  	var (
   550  		localVarHttpMethod = strings.ToUpper("Post")
   551  		localVarPostBody   interface{}
   552  		localVarFileName   string
   553  		localVarFileBytes  []byte
   554  		successPayload     manager.L4PortSetNsService
   555  	)
   556  
   557  	// set resource type for this type-specific API
   558  	nSService.ResourceType = "L4PortSetNSService"
   559  
   560  	// create path and map variables
   561  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   562  
   563  	localVarHeaderParams := make(map[string]string)
   564  	localVarQueryParams := url.Values{}
   565  	localVarFormParams := url.Values{}
   566  
   567  	// to determine the Content-Type header
   568  	localVarHttpContentTypes := []string{"application/json"}
   569  
   570  	// set Content-Type header
   571  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   572  	if localVarHttpContentType != "" {
   573  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   574  	}
   575  
   576  	// to determine the Accept header
   577  	localVarHttpHeaderAccepts := []string{
   578  		"application/json",
   579  	}
   580  
   581  	// set Accept header
   582  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   583  	if localVarHttpHeaderAccept != "" {
   584  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   585  	}
   586  	// body params
   587  	localVarPostBody = &nSService
   588  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   589  	if err != nil {
   590  		return successPayload, nil, err
   591  	}
   592  
   593  	localVarHttpResponse, err := a.client.callAPI(r)
   594  	if err != nil || localVarHttpResponse == nil {
   595  		return successPayload, localVarHttpResponse, err
   596  	}
   597  	defer localVarHttpResponse.Body.Close()
   598  	if localVarHttpResponse.StatusCode >= 300 {
   599  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   600  	}
   601  
   602  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   603  		return successPayload, localVarHttpResponse, err
   604  	}
   605  
   606  	return successPayload, localVarHttpResponse, err
   607  }
   608  
   609  /* GroupingObjectsApiService Create IcmpTypeNSService
   610  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   611  * @param ctx context.Context Authentication Context
   612  @param nSService
   613  @return manager.NsService*/
   614  func (a *GroupingObjectsApiService) CreateIcmpTypeNSService(ctx context.Context, nSService manager.IcmpTypeNsService) (manager.IcmpTypeNsService, *http.Response, error) {
   615  	var (
   616  		localVarHttpMethod = strings.ToUpper("Post")
   617  		localVarPostBody   interface{}
   618  		localVarFileName   string
   619  		localVarFileBytes  []byte
   620  		successPayload     manager.IcmpTypeNsService
   621  	)
   622  
   623  	// set resource type for this type-specific API
   624  	nSService.ResourceType = "ICMPTypeNSService"
   625  
   626  	// create path and map variables
   627  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   628  
   629  	localVarHeaderParams := make(map[string]string)
   630  	localVarQueryParams := url.Values{}
   631  	localVarFormParams := url.Values{}
   632  
   633  	// to determine the Content-Type header
   634  	localVarHttpContentTypes := []string{"application/json"}
   635  
   636  	// set Content-Type header
   637  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   638  	if localVarHttpContentType != "" {
   639  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   640  	}
   641  
   642  	// to determine the Accept header
   643  	localVarHttpHeaderAccepts := []string{
   644  		"application/json",
   645  	}
   646  
   647  	// set Accept header
   648  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   649  	if localVarHttpHeaderAccept != "" {
   650  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   651  	}
   652  	// body params
   653  	localVarPostBody = &nSService
   654  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   655  	if err != nil {
   656  		return successPayload, nil, err
   657  	}
   658  
   659  	localVarHttpResponse, err := a.client.callAPI(r)
   660  	if err != nil || localVarHttpResponse == nil {
   661  		return successPayload, localVarHttpResponse, err
   662  	}
   663  	defer localVarHttpResponse.Body.Close()
   664  	if localVarHttpResponse.StatusCode >= 300 {
   665  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   666  	}
   667  
   668  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   669  		return successPayload, localVarHttpResponse, err
   670  	}
   671  
   672  	return successPayload, localVarHttpResponse, err
   673  }
   674  
   675  /* GroupingObjectsApiService Create IgmpTypeNSService
   676  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   677  * @param ctx context.Context Authentication Context
   678  @param nSService
   679  @return manager.NsService*/
   680  func (a *GroupingObjectsApiService) CreateIgmpTypeNSService(ctx context.Context, nSService manager.IgmpTypeNsService) (manager.IgmpTypeNsService, *http.Response, error) {
   681  	var (
   682  		localVarHttpMethod = strings.ToUpper("Post")
   683  		localVarPostBody   interface{}
   684  		localVarFileName   string
   685  		localVarFileBytes  []byte
   686  		successPayload     manager.IgmpTypeNsService
   687  	)
   688  
   689  	// set resource type for this type-specific API
   690  	nSService.ResourceType = "IGMPTypeNSService"
   691  
   692  	// create path and map variables
   693  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   694  
   695  	localVarHeaderParams := make(map[string]string)
   696  	localVarQueryParams := url.Values{}
   697  	localVarFormParams := url.Values{}
   698  
   699  	// to determine the Content-Type header
   700  	localVarHttpContentTypes := []string{"application/json"}
   701  
   702  	// set Content-Type header
   703  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   704  	if localVarHttpContentType != "" {
   705  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   706  	}
   707  
   708  	// to determine the Accept header
   709  	localVarHttpHeaderAccepts := []string{
   710  		"application/json",
   711  	}
   712  
   713  	// set Accept header
   714  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   715  	if localVarHttpHeaderAccept != "" {
   716  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   717  	}
   718  	// body params
   719  	localVarPostBody = &nSService
   720  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   721  	if err != nil {
   722  		return successPayload, nil, err
   723  	}
   724  
   725  	localVarHttpResponse, err := a.client.callAPI(r)
   726  	if err != nil || localVarHttpResponse == nil {
   727  		return successPayload, localVarHttpResponse, err
   728  	}
   729  	defer localVarHttpResponse.Body.Close()
   730  	if localVarHttpResponse.StatusCode >= 300 {
   731  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   732  	}
   733  
   734  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   735  		return successPayload, localVarHttpResponse, err
   736  	}
   737  
   738  	return successPayload, localVarHttpResponse, err
   739  }
   740  
   741  /* GroupingObjectsApiService Create AlgTypeNSService
   742  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   743  * @param ctx context.Context Authentication Context
   744  @param nSService
   745  @return manager.NsService*/
   746  func (a *GroupingObjectsApiService) CreateAlgTypeNSService(ctx context.Context, nSService manager.AlgTypeNsService) (manager.AlgTypeNsService, *http.Response, error) {
   747  	var (
   748  		localVarHttpMethod = strings.ToUpper("Post")
   749  		localVarPostBody   interface{}
   750  		localVarFileName   string
   751  		localVarFileBytes  []byte
   752  		successPayload     manager.AlgTypeNsService
   753  	)
   754  
   755  	// set resource type for this type-specific API
   756  	nSService.ResourceType = "ALGTypeNSService"
   757  
   758  	// create path and map variables
   759  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   760  
   761  	localVarHeaderParams := make(map[string]string)
   762  	localVarQueryParams := url.Values{}
   763  	localVarFormParams := url.Values{}
   764  
   765  	// to determine the Content-Type header
   766  	localVarHttpContentTypes := []string{"application/json"}
   767  
   768  	// set Content-Type header
   769  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   770  	if localVarHttpContentType != "" {
   771  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   772  	}
   773  
   774  	// to determine the Accept header
   775  	localVarHttpHeaderAccepts := []string{
   776  		"application/json",
   777  	}
   778  
   779  	// set Accept header
   780  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   781  	if localVarHttpHeaderAccept != "" {
   782  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   783  	}
   784  	// body params
   785  	localVarPostBody = &nSService
   786  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   787  	if err != nil {
   788  		return successPayload, nil, err
   789  	}
   790  
   791  	localVarHttpResponse, err := a.client.callAPI(r)
   792  	if err != nil || localVarHttpResponse == nil {
   793  		return successPayload, localVarHttpResponse, err
   794  	}
   795  	defer localVarHttpResponse.Body.Close()
   796  	if localVarHttpResponse.StatusCode >= 300 {
   797  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   798  	}
   799  
   800  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   801  		return successPayload, localVarHttpResponse, err
   802  	}
   803  
   804  	return successPayload, localVarHttpResponse, err
   805  }
   806  
   807  /* GroupingObjectsApiService Create EtherTypeNSService
   808  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   809  * @param ctx context.Context Authentication Context
   810  @param nSService
   811  @return manager.NsService*/
   812  func (a *GroupingObjectsApiService) CreateEtherTypeNSService(ctx context.Context, nSService manager.EtherTypeNsService) (manager.EtherTypeNsService, *http.Response, error) {
   813  	var (
   814  		localVarHttpMethod = strings.ToUpper("Post")
   815  		localVarPostBody   interface{}
   816  		localVarFileName   string
   817  		localVarFileBytes  []byte
   818  		successPayload     manager.EtherTypeNsService
   819  	)
   820  
   821  	// set resource type for this type-specific API
   822  	nSService.ResourceType = "EtherTypeNSService"
   823  
   824  	// create path and map variables
   825  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   826  
   827  	localVarHeaderParams := make(map[string]string)
   828  	localVarQueryParams := url.Values{}
   829  	localVarFormParams := url.Values{}
   830  
   831  	// to determine the Content-Type header
   832  	localVarHttpContentTypes := []string{"application/json"}
   833  
   834  	// set Content-Type header
   835  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   836  	if localVarHttpContentType != "" {
   837  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   838  	}
   839  
   840  	// to determine the Accept header
   841  	localVarHttpHeaderAccepts := []string{
   842  		"application/json",
   843  	}
   844  
   845  	// set Accept header
   846  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   847  	if localVarHttpHeaderAccept != "" {
   848  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   849  	}
   850  	// body params
   851  	localVarPostBody = &nSService
   852  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   853  	if err != nil {
   854  		return successPayload, nil, err
   855  	}
   856  
   857  	localVarHttpResponse, err := a.client.callAPI(r)
   858  	if err != nil || localVarHttpResponse == nil {
   859  		return successPayload, localVarHttpResponse, err
   860  	}
   861  	defer localVarHttpResponse.Body.Close()
   862  	if localVarHttpResponse.StatusCode >= 300 {
   863  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   864  	}
   865  
   866  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   867  		return successPayload, localVarHttpResponse, err
   868  	}
   869  
   870  	return successPayload, localVarHttpResponse, err
   871  }
   872  
   873  /* GroupingObjectsApiService Create IpProtocolNSService
   874  Creates a new NSService which allows users to specify characteristics to use for matching network traffic.
   875  * @param ctx context.Context Authentication Context
   876  @param nSService
   877  @return manager.NsService*/
   878  func (a *GroupingObjectsApiService) CreateIpProtocolNSService(ctx context.Context, nSService manager.IpProtocolNsService) (manager.IpProtocolNsService, *http.Response, error) {
   879  	var (
   880  		localVarHttpMethod = strings.ToUpper("Post")
   881  		localVarPostBody   interface{}
   882  		localVarFileName   string
   883  		localVarFileBytes  []byte
   884  		successPayload     manager.IpProtocolNsService
   885  	)
   886  
   887  	// set resource type for this type-specific API
   888  	nSService.ResourceType = "IPProtocolNSService"
   889  
   890  	// create path and map variables
   891  	localVarPath := a.client.cfg.BasePath + "/ns-services"
   892  
   893  	localVarHeaderParams := make(map[string]string)
   894  	localVarQueryParams := url.Values{}
   895  	localVarFormParams := url.Values{}
   896  
   897  	// to determine the Content-Type header
   898  	localVarHttpContentTypes := []string{"application/json"}
   899  
   900  	// set Content-Type header
   901  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   902  	if localVarHttpContentType != "" {
   903  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   904  	}
   905  
   906  	// to determine the Accept header
   907  	localVarHttpHeaderAccepts := []string{
   908  		"application/json",
   909  	}
   910  
   911  	// set Accept header
   912  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   913  	if localVarHttpHeaderAccept != "" {
   914  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   915  	}
   916  	// body params
   917  	localVarPostBody = &nSService
   918  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   919  	if err != nil {
   920  		return successPayload, nil, err
   921  	}
   922  
   923  	localVarHttpResponse, err := a.client.callAPI(r)
   924  	if err != nil || localVarHttpResponse == nil {
   925  		return successPayload, localVarHttpResponse, err
   926  	}
   927  	defer localVarHttpResponse.Body.Close()
   928  	if localVarHttpResponse.StatusCode >= 300 {
   929  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   930  	}
   931  
   932  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   933  		return successPayload, localVarHttpResponse, err
   934  	}
   935  
   936  	return successPayload, localVarHttpResponse, err
   937  }
   938  
   939  /* GroupingObjectsApiService Create NSServiceGroup
   940  Creates a new NSServiceGroup which can contain NSServices. A given NSServiceGroup can contain either only ether type of NSServices or only non-ether type of NSServices, i.e. an NSServiceGroup cannot contain a mix of both ether and non-ether types of NSServices.
   941  * @param ctx context.Context Authentication Context
   942  @param nSServiceGroup
   943  @return manager.NsServiceGroup*/
   944  func (a *GroupingObjectsApiService) CreateNSServiceGroup(ctx context.Context, nSServiceGroup manager.NsServiceGroup) (manager.NsServiceGroup, *http.Response, error) {
   945  	var (
   946  		localVarHttpMethod = strings.ToUpper("Post")
   947  		localVarPostBody   interface{}
   948  		localVarFileName   string
   949  		localVarFileBytes  []byte
   950  		successPayload     manager.NsServiceGroup
   951  	)
   952  
   953  	// create path and map variables
   954  	localVarPath := a.client.cfg.BasePath + "/ns-service-groups"
   955  
   956  	localVarHeaderParams := make(map[string]string)
   957  	localVarQueryParams := url.Values{}
   958  	localVarFormParams := url.Values{}
   959  
   960  	// to determine the Content-Type header
   961  	localVarHttpContentTypes := []string{"application/json"}
   962  
   963  	// set Content-Type header
   964  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
   965  	if localVarHttpContentType != "" {
   966  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
   967  	}
   968  
   969  	// to determine the Accept header
   970  	localVarHttpHeaderAccepts := []string{
   971  		"application/json",
   972  	}
   973  
   974  	// set Accept header
   975  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
   976  	if localVarHttpHeaderAccept != "" {
   977  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
   978  	}
   979  	// body params
   980  	localVarPostBody = &nSServiceGroup
   981  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
   982  	if err != nil {
   983  		return successPayload, nil, err
   984  	}
   985  
   986  	localVarHttpResponse, err := a.client.callAPI(r)
   987  	if err != nil || localVarHttpResponse == nil {
   988  		return successPayload, localVarHttpResponse, err
   989  	}
   990  	defer localVarHttpResponse.Body.Close()
   991  	if localVarHttpResponse.StatusCode >= 300 {
   992  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
   993  	}
   994  
   995  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
   996  		return successPayload, localVarHttpResponse, err
   997  	}
   998  
   999  	return successPayload, localVarHttpResponse, err
  1000  }
  1001  
  1002  /* GroupingObjectsApiService Delete IPSet
  1003  Deletes the specified IPSet.  By default, if the IPSet is added to an NSGroup, it won't be deleted. In such situations, pass \"force=true\" as query param to force delete the IPSet.
  1004  * @param ctx context.Context Authentication Context
  1005  @param ipSetId IPSet Id
  1006  @param optional (nil or map[string]interface{}) with one or more of:
  1007      @param "force" (bool) Force delete the resource even if it is being used somewhere
  1008  @return */
  1009  func (a *GroupingObjectsApiService) DeleteIPSet(ctx context.Context, ipSetId string, localVarOptionals map[string]interface{}) (*http.Response, error) {
  1010  	var (
  1011  		localVarHttpMethod = strings.ToUpper("Delete")
  1012  		localVarPostBody   interface{}
  1013  		localVarFileName   string
  1014  		localVarFileBytes  []byte
  1015  	)
  1016  
  1017  	// create path and map variables
  1018  	localVarPath := a.client.cfg.BasePath + "/ip-sets/{ip-set-id}"
  1019  	localVarPath = strings.Replace(localVarPath, "{"+"ip-set-id"+"}", fmt.Sprintf("%v", ipSetId), -1)
  1020  
  1021  	localVarHeaderParams := make(map[string]string)
  1022  	localVarQueryParams := url.Values{}
  1023  	localVarFormParams := url.Values{}
  1024  
  1025  	if err := typeCheckParameter(localVarOptionals["force"], "bool", "force"); err != nil {
  1026  		return nil, err
  1027  	}
  1028  
  1029  	if localVarTempParam, localVarOk := localVarOptionals["force"].(bool); localVarOk {
  1030  		localVarQueryParams.Add("force", parameterToString(localVarTempParam, ""))
  1031  	}
  1032  	// to determine the Content-Type header
  1033  	localVarHttpContentTypes := []string{"application/json"}
  1034  
  1035  	// set Content-Type header
  1036  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1037  	if localVarHttpContentType != "" {
  1038  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1039  	}
  1040  
  1041  	// to determine the Accept header
  1042  	localVarHttpHeaderAccepts := []string{
  1043  		"application/json",
  1044  	}
  1045  
  1046  	// set Accept header
  1047  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1048  	if localVarHttpHeaderAccept != "" {
  1049  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1050  	}
  1051  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1052  	if err != nil {
  1053  		return nil, err
  1054  	}
  1055  
  1056  	localVarHttpResponse, err := a.client.callAPI(r)
  1057  	if err != nil || localVarHttpResponse == nil {
  1058  		return localVarHttpResponse, err
  1059  	}
  1060  	defer localVarHttpResponse.Body.Close()
  1061  	if localVarHttpResponse.StatusCode >= 300 {
  1062  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1063  	}
  1064  
  1065  	return localVarHttpResponse, err
  1066  }
  1067  
  1068  /* GroupingObjectsApiService Delete MACSet
  1069  Deletes the specified MACSet. By default, if the MACSet is added to an NSGroup, it won't be deleted. In such situations, pass \"force=true\" as query param to force delete the MACSet.
  1070  * @param ctx context.Context Authentication Context
  1071  @param macSetId MACSet Id
  1072  @param optional (nil or map[string]interface{}) with one or more of:
  1073      @param "force" (bool) Force delete the resource even if it is being used somewhere
  1074  @return */
  1075  func (a *GroupingObjectsApiService) DeleteMACSet(ctx context.Context, macSetId string, localVarOptionals map[string]interface{}) (*http.Response, error) {
  1076  	var (
  1077  		localVarHttpMethod = strings.ToUpper("Delete")
  1078  		localVarPostBody   interface{}
  1079  		localVarFileName   string
  1080  		localVarFileBytes  []byte
  1081  	)
  1082  
  1083  	// create path and map variables
  1084  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}"
  1085  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -1)
  1086  
  1087  	localVarHeaderParams := make(map[string]string)
  1088  	localVarQueryParams := url.Values{}
  1089  	localVarFormParams := url.Values{}
  1090  
  1091  	if err := typeCheckParameter(localVarOptionals["force"], "bool", "force"); err != nil {
  1092  		return nil, err
  1093  	}
  1094  
  1095  	if localVarTempParam, localVarOk := localVarOptionals["force"].(bool); localVarOk {
  1096  		localVarQueryParams.Add("force", parameterToString(localVarTempParam, ""))
  1097  	}
  1098  	// to determine the Content-Type header
  1099  	localVarHttpContentTypes := []string{"application/json"}
  1100  
  1101  	// set Content-Type header
  1102  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1103  	if localVarHttpContentType != "" {
  1104  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1105  	}
  1106  
  1107  	// to determine the Accept header
  1108  	localVarHttpHeaderAccepts := []string{
  1109  		"application/json",
  1110  	}
  1111  
  1112  	// set Accept header
  1113  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1114  	if localVarHttpHeaderAccept != "" {
  1115  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1116  	}
  1117  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1118  	if err != nil {
  1119  		return nil, err
  1120  	}
  1121  
  1122  	localVarHttpResponse, err := a.client.callAPI(r)
  1123  	if err != nil || localVarHttpResponse == nil {
  1124  		return localVarHttpResponse, err
  1125  	}
  1126  	defer localVarHttpResponse.Body.Close()
  1127  	if localVarHttpResponse.StatusCode >= 300 {
  1128  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1129  	}
  1130  
  1131  	return localVarHttpResponse, err
  1132  }
  1133  
  1134  /* GroupingObjectsApiService Delete NSGroup
  1135  Deletes the specified NSGroup. By default, if the NSGroup is added to another NSGroup, it won't be deleted. In such situations, pass \"force=true\" as query param to force delete the NSGroup.
  1136  * @param ctx context.Context Authentication Context
  1137  @param nsGroupId NSGroup Id
  1138  @param optional (nil or map[string]interface{}) with one or more of:
  1139      @param "force" (bool) Force delete the resource even if it is being used somewhere
  1140  @return */
  1141  func (a *GroupingObjectsApiService) DeleteNSGroup(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (*http.Response, error) {
  1142  	var (
  1143  		localVarHttpMethod = strings.ToUpper("Delete")
  1144  		localVarPostBody   interface{}
  1145  		localVarFileName   string
  1146  		localVarFileBytes  []byte
  1147  	)
  1148  
  1149  	// create path and map variables
  1150  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
  1151  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1152  
  1153  	localVarHeaderParams := make(map[string]string)
  1154  	localVarQueryParams := url.Values{}
  1155  	localVarFormParams := url.Values{}
  1156  
  1157  	if err := typeCheckParameter(localVarOptionals["force"], "bool", "force"); err != nil {
  1158  		return nil, err
  1159  	}
  1160  
  1161  	if localVarTempParam, localVarOk := localVarOptionals["force"].(bool); localVarOk {
  1162  		localVarQueryParams.Add("force", parameterToString(localVarTempParam, ""))
  1163  	}
  1164  	// to determine the Content-Type header
  1165  	localVarHttpContentTypes := []string{"application/json"}
  1166  
  1167  	// set Content-Type header
  1168  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1169  	if localVarHttpContentType != "" {
  1170  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1171  	}
  1172  
  1173  	// to determine the Accept header
  1174  	localVarHttpHeaderAccepts := []string{
  1175  		"application/json",
  1176  	}
  1177  
  1178  	// set Accept header
  1179  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1180  	if localVarHttpHeaderAccept != "" {
  1181  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1182  	}
  1183  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1184  	if err != nil {
  1185  		return nil, err
  1186  	}
  1187  
  1188  	localVarHttpResponse, err := a.client.callAPI(r)
  1189  	if err != nil || localVarHttpResponse == nil {
  1190  		return localVarHttpResponse, err
  1191  	}
  1192  	defer localVarHttpResponse.Body.Close()
  1193  	if localVarHttpResponse.StatusCode >= 300 {
  1194  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1195  	}
  1196  
  1197  	return localVarHttpResponse, err
  1198  }
  1199  
  1200  /* GroupingObjectsApiService Delete NSService
  1201  Deletes the specified NSService. By default, if the NSService is being referred in an NSServiceGroup, it can't be deleted. In such situations, pass \"force=true\" as a parameter to force delete the NSService. System defined NSServices can't be deleted using \"force\" flag.
  1202  * @param ctx context.Context Authentication Context
  1203  @param nsServiceId NSService Id
  1204  @param optional (nil or map[string]interface{}) with one or more of:
  1205      @param "force" (bool) Force delete the resource even if it is being used somewhere
  1206  @return */
  1207  func (a *GroupingObjectsApiService) DeleteNSService(ctx context.Context, nsServiceId string, localVarOptionals map[string]interface{}) (*http.Response, error) {
  1208  	var (
  1209  		localVarHttpMethod = strings.ToUpper("Delete")
  1210  		localVarPostBody   interface{}
  1211  		localVarFileName   string
  1212  		localVarFileBytes  []byte
  1213  	)
  1214  
  1215  	// create path and map variables
  1216  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  1217  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  1218  
  1219  	localVarHeaderParams := make(map[string]string)
  1220  	localVarQueryParams := url.Values{}
  1221  	localVarFormParams := url.Values{}
  1222  
  1223  	if err := typeCheckParameter(localVarOptionals["force"], "bool", "force"); err != nil {
  1224  		return nil, err
  1225  	}
  1226  
  1227  	if localVarTempParam, localVarOk := localVarOptionals["force"].(bool); localVarOk {
  1228  		localVarQueryParams.Add("force", parameterToString(localVarTempParam, ""))
  1229  	}
  1230  	// to determine the Content-Type header
  1231  	localVarHttpContentTypes := []string{"application/json"}
  1232  
  1233  	// set Content-Type header
  1234  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1235  	if localVarHttpContentType != "" {
  1236  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1237  	}
  1238  
  1239  	// to determine the Accept header
  1240  	localVarHttpHeaderAccepts := []string{
  1241  		"application/json",
  1242  	}
  1243  
  1244  	// set Accept header
  1245  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1246  	if localVarHttpHeaderAccept != "" {
  1247  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1248  	}
  1249  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1250  	if err != nil {
  1251  		return nil, err
  1252  	}
  1253  
  1254  	localVarHttpResponse, err := a.client.callAPI(r)
  1255  	if err != nil || localVarHttpResponse == nil {
  1256  		return localVarHttpResponse, err
  1257  	}
  1258  	defer localVarHttpResponse.Body.Close()
  1259  	if localVarHttpResponse.StatusCode >= 300 {
  1260  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1261  	}
  1262  
  1263  	return localVarHttpResponse, err
  1264  }
  1265  
  1266  /* GroupingObjectsApiService Delete NSServiceGroup
  1267  Deletes the specified NSServiceGroup. By default, if the NSServiceGroup is consumed in a Firewall rule, it won't get deleted. In such situations, pass \"force=true\" as query param to force delete the NSServiceGroup.
  1268  * @param ctx context.Context Authentication Context
  1269  @param nsServiceGroupId NSServiceGroup Id
  1270  @param optional (nil or map[string]interface{}) with one or more of:
  1271      @param "force" (bool) Force delete the resource even if it is being used somewhere
  1272  @return */
  1273  func (a *GroupingObjectsApiService) DeleteNSServiceGroup(ctx context.Context, nsServiceGroupId string, localVarOptionals map[string]interface{}) (*http.Response, error) {
  1274  	var (
  1275  		localVarHttpMethod = strings.ToUpper("Delete")
  1276  		localVarPostBody   interface{}
  1277  		localVarFileName   string
  1278  		localVarFileBytes  []byte
  1279  	)
  1280  
  1281  	// create path and map variables
  1282  	localVarPath := a.client.cfg.BasePath + "/ns-service-groups/{ns-service-group-id}"
  1283  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-group-id"+"}", fmt.Sprintf("%v", nsServiceGroupId), -1)
  1284  
  1285  	localVarHeaderParams := make(map[string]string)
  1286  	localVarQueryParams := url.Values{}
  1287  	localVarFormParams := url.Values{}
  1288  
  1289  	if err := typeCheckParameter(localVarOptionals["force"], "bool", "force"); err != nil {
  1290  		return nil, err
  1291  	}
  1292  
  1293  	if localVarTempParam, localVarOk := localVarOptionals["force"].(bool); localVarOk {
  1294  		localVarQueryParams.Add("force", parameterToString(localVarTempParam, ""))
  1295  	}
  1296  	// to determine the Content-Type header
  1297  	localVarHttpContentTypes := []string{"application/json"}
  1298  
  1299  	// set Content-Type header
  1300  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1301  	if localVarHttpContentType != "" {
  1302  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1303  	}
  1304  
  1305  	// to determine the Accept header
  1306  	localVarHttpHeaderAccepts := []string{
  1307  		"application/json",
  1308  	}
  1309  
  1310  	// set Accept header
  1311  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1312  	if localVarHttpHeaderAccept != "" {
  1313  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1314  	}
  1315  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1316  	if err != nil {
  1317  		return nil, err
  1318  	}
  1319  
  1320  	localVarHttpResponse, err := a.client.callAPI(r)
  1321  	if err != nil || localVarHttpResponse == nil {
  1322  		return localVarHttpResponse, err
  1323  	}
  1324  	defer localVarHttpResponse.Body.Close()
  1325  	if localVarHttpResponse.StatusCode >= 300 {
  1326  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1327  	}
  1328  
  1329  	return localVarHttpResponse, err
  1330  }
  1331  
  1332  /* GroupingObjectsApiService Get Effective IPAddress translated from the NSGroup
  1333  Returns effective ip address members of the specified NSGroup.
  1334  * @param ctx context.Context Authentication Context
  1335  @param nsGroupId NSGroup Id
  1336  @param optional (nil or map[string]interface{}) with one or more of:
  1337      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1338      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1339      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1340      @param "sortAscending" (bool)
  1341      @param "sortBy" (string) Field by which records are sorted
  1342  @return manager.EffectiveIpAddressMemberListResult*/
  1343  func (a *GroupingObjectsApiService) GetEffectiveIPAddressMembers(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.EffectiveIpAddressMemberListResult, *http.Response, error) {
  1344  	var (
  1345  		localVarHttpMethod = strings.ToUpper("Get")
  1346  		localVarPostBody   interface{}
  1347  		localVarFileName   string
  1348  		localVarFileBytes  []byte
  1349  		successPayload     manager.EffectiveIpAddressMemberListResult
  1350  	)
  1351  
  1352  	// create path and map variables
  1353  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}/effective-ip-address-members"
  1354  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1355  
  1356  	localVarHeaderParams := make(map[string]string)
  1357  	localVarQueryParams := url.Values{}
  1358  	localVarFormParams := url.Values{}
  1359  
  1360  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1361  		return successPayload, nil, err
  1362  	}
  1363  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1364  		return successPayload, nil, err
  1365  	}
  1366  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1367  		return successPayload, nil, err
  1368  	}
  1369  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1370  		return successPayload, nil, err
  1371  	}
  1372  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1373  		return successPayload, nil, err
  1374  	}
  1375  
  1376  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1377  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1378  	}
  1379  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1380  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1381  	}
  1382  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1383  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1384  	}
  1385  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1386  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1387  	}
  1388  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1389  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1390  	}
  1391  	// to determine the Content-Type header
  1392  	localVarHttpContentTypes := []string{"application/json"}
  1393  
  1394  	// set Content-Type header
  1395  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1396  	if localVarHttpContentType != "" {
  1397  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1398  	}
  1399  
  1400  	// to determine the Accept header
  1401  	localVarHttpHeaderAccepts := []string{
  1402  		"application/json",
  1403  	}
  1404  
  1405  	// set Accept header
  1406  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1407  	if localVarHttpHeaderAccept != "" {
  1408  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1409  	}
  1410  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1411  	if err != nil {
  1412  		return successPayload, nil, err
  1413  	}
  1414  
  1415  	localVarHttpResponse, err := a.client.callAPI(r)
  1416  	if err != nil || localVarHttpResponse == nil {
  1417  		return successPayload, localVarHttpResponse, err
  1418  	}
  1419  	defer localVarHttpResponse.Body.Close()
  1420  	if localVarHttpResponse.StatusCode >= 300 {
  1421  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1422  	}
  1423  
  1424  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1425  		return successPayload, localVarHttpResponse, err
  1426  	}
  1427  
  1428  	return successPayload, localVarHttpResponse, err
  1429  }
  1430  
  1431  /* GroupingObjectsApiService Get Effective Logical Ports translated from the NSgroup
  1432  Returns effective logical port members of the specified NSGroup.
  1433  * @param ctx context.Context Authentication Context
  1434  @param nsGroupId NSGroup Id
  1435  @param optional (nil or map[string]interface{}) with one or more of:
  1436      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1437      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1438      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1439      @param "sortAscending" (bool)
  1440      @param "sortBy" (string) Field by which records are sorted
  1441  @return manager.EffectiveMemberResourceListResult*/
  1442  func (a *GroupingObjectsApiService) GetEffectiveLogicalPortMembers(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.EffectiveMemberResourceListResult, *http.Response, error) {
  1443  	var (
  1444  		localVarHttpMethod = strings.ToUpper("Get")
  1445  		localVarPostBody   interface{}
  1446  		localVarFileName   string
  1447  		localVarFileBytes  []byte
  1448  		successPayload     manager.EffectiveMemberResourceListResult
  1449  	)
  1450  
  1451  	// create path and map variables
  1452  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}/effective-logical-port-members"
  1453  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1454  
  1455  	localVarHeaderParams := make(map[string]string)
  1456  	localVarQueryParams := url.Values{}
  1457  	localVarFormParams := url.Values{}
  1458  
  1459  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1460  		return successPayload, nil, err
  1461  	}
  1462  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1463  		return successPayload, nil, err
  1464  	}
  1465  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1466  		return successPayload, nil, err
  1467  	}
  1468  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1469  		return successPayload, nil, err
  1470  	}
  1471  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1472  		return successPayload, nil, err
  1473  	}
  1474  
  1475  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1476  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1477  	}
  1478  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1479  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1480  	}
  1481  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1482  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1483  	}
  1484  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1485  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1486  	}
  1487  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1488  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1489  	}
  1490  	// to determine the Content-Type header
  1491  	localVarHttpContentTypes := []string{"application/json"}
  1492  
  1493  	// set Content-Type header
  1494  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1495  	if localVarHttpContentType != "" {
  1496  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1497  	}
  1498  
  1499  	// to determine the Accept header
  1500  	localVarHttpHeaderAccepts := []string{
  1501  		"application/json",
  1502  	}
  1503  
  1504  	// set Accept header
  1505  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1506  	if localVarHttpHeaderAccept != "" {
  1507  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1508  	}
  1509  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1510  	if err != nil {
  1511  		return successPayload, nil, err
  1512  	}
  1513  
  1514  	localVarHttpResponse, err := a.client.callAPI(r)
  1515  	if err != nil || localVarHttpResponse == nil {
  1516  		return successPayload, localVarHttpResponse, err
  1517  	}
  1518  	defer localVarHttpResponse.Body.Close()
  1519  	if localVarHttpResponse.StatusCode >= 300 {
  1520  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1521  	}
  1522  
  1523  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1524  		return successPayload, localVarHttpResponse, err
  1525  	}
  1526  
  1527  	return successPayload, localVarHttpResponse, err
  1528  }
  1529  
  1530  /* GroupingObjectsApiService Get Effective switch members translated from the NSGroup
  1531  Returns effective logical switch members of the specified NSGroup.
  1532  * @param ctx context.Context Authentication Context
  1533  @param nsGroupId NSGroup Id
  1534  @param optional (nil or map[string]interface{}) with one or more of:
  1535      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1536      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1537      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1538      @param "sortAscending" (bool)
  1539      @param "sortBy" (string) Field by which records are sorted
  1540  @return manager.EffectiveMemberResourceListResult*/
  1541  func (a *GroupingObjectsApiService) GetEffectiveLogicalSwitchMembers(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.EffectiveMemberResourceListResult, *http.Response, error) {
  1542  	var (
  1543  		localVarHttpMethod = strings.ToUpper("Get")
  1544  		localVarPostBody   interface{}
  1545  		localVarFileName   string
  1546  		localVarFileBytes  []byte
  1547  		successPayload     manager.EffectiveMemberResourceListResult
  1548  	)
  1549  
  1550  	// create path and map variables
  1551  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}/effective-logical-switch-members"
  1552  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1553  
  1554  	localVarHeaderParams := make(map[string]string)
  1555  	localVarQueryParams := url.Values{}
  1556  	localVarFormParams := url.Values{}
  1557  
  1558  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1559  		return successPayload, nil, err
  1560  	}
  1561  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1562  		return successPayload, nil, err
  1563  	}
  1564  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1565  		return successPayload, nil, err
  1566  	}
  1567  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1568  		return successPayload, nil, err
  1569  	}
  1570  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1571  		return successPayload, nil, err
  1572  	}
  1573  
  1574  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1575  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1576  	}
  1577  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1578  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1579  	}
  1580  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1581  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1582  	}
  1583  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1584  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1585  	}
  1586  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1587  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1588  	}
  1589  	// to determine the Content-Type header
  1590  	localVarHttpContentTypes := []string{"application/json"}
  1591  
  1592  	// set Content-Type header
  1593  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1594  	if localVarHttpContentType != "" {
  1595  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1596  	}
  1597  
  1598  	// to determine the Accept header
  1599  	localVarHttpHeaderAccepts := []string{
  1600  		"application/json",
  1601  	}
  1602  
  1603  	// set Accept header
  1604  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1605  	if localVarHttpHeaderAccept != "" {
  1606  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1607  	}
  1608  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1609  	if err != nil {
  1610  		return successPayload, nil, err
  1611  	}
  1612  
  1613  	localVarHttpResponse, err := a.client.callAPI(r)
  1614  	if err != nil || localVarHttpResponse == nil {
  1615  		return successPayload, localVarHttpResponse, err
  1616  	}
  1617  	defer localVarHttpResponse.Body.Close()
  1618  	if localVarHttpResponse.StatusCode >= 300 {
  1619  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1620  	}
  1621  
  1622  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1623  		return successPayload, localVarHttpResponse, err
  1624  	}
  1625  
  1626  	return successPayload, localVarHttpResponse, err
  1627  }
  1628  
  1629  /* GroupingObjectsApiService Get Effective Virtual Machine members of the specified NSGroup.
  1630  Returns effective virtual machine members of the specified NSGroup.
  1631  * @param ctx context.Context Authentication Context
  1632  @param nsGroupId NSGroup Id
  1633  @param optional (nil or map[string]interface{}) with one or more of:
  1634      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1635      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1636      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1637      @param "sortAscending" (bool)
  1638      @param "sortBy" (string) Field by which records are sorted
  1639  @return manager.VirtualMachineListResult*/
  1640  func (a *GroupingObjectsApiService) GetEffectiveVirtualMachineMembers(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.VirtualMachineListResult, *http.Response, error) {
  1641  	var (
  1642  		localVarHttpMethod = strings.ToUpper("Get")
  1643  		localVarPostBody   interface{}
  1644  		localVarFileName   string
  1645  		localVarFileBytes  []byte
  1646  		successPayload     manager.VirtualMachineListResult
  1647  	)
  1648  
  1649  	// create path and map variables
  1650  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}/effective-virtual-machine-members"
  1651  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1652  
  1653  	localVarHeaderParams := make(map[string]string)
  1654  	localVarQueryParams := url.Values{}
  1655  	localVarFormParams := url.Values{}
  1656  
  1657  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1658  		return successPayload, nil, err
  1659  	}
  1660  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1661  		return successPayload, nil, err
  1662  	}
  1663  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1664  		return successPayload, nil, err
  1665  	}
  1666  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1667  		return successPayload, nil, err
  1668  	}
  1669  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1670  		return successPayload, nil, err
  1671  	}
  1672  
  1673  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1674  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1675  	}
  1676  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1677  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1678  	}
  1679  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1680  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1681  	}
  1682  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1683  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1684  	}
  1685  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1686  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1687  	}
  1688  	// to determine the Content-Type header
  1689  	localVarHttpContentTypes := []string{"application/json"}
  1690  
  1691  	// set Content-Type header
  1692  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1693  	if localVarHttpContentType != "" {
  1694  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1695  	}
  1696  
  1697  	// to determine the Accept header
  1698  	localVarHttpHeaderAccepts := []string{
  1699  		"application/json",
  1700  	}
  1701  
  1702  	// set Accept header
  1703  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1704  	if localVarHttpHeaderAccept != "" {
  1705  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1706  	}
  1707  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1708  	if err != nil {
  1709  		return successPayload, nil, err
  1710  	}
  1711  
  1712  	localVarHttpResponse, err := a.client.callAPI(r)
  1713  	if err != nil || localVarHttpResponse == nil {
  1714  		return successPayload, localVarHttpResponse, err
  1715  	}
  1716  	defer localVarHttpResponse.Body.Close()
  1717  	if localVarHttpResponse.StatusCode >= 300 {
  1718  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1719  	}
  1720  
  1721  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1722  		return successPayload, localVarHttpResponse, err
  1723  	}
  1724  
  1725  	return successPayload, localVarHttpResponse, err
  1726  }
  1727  
  1728  /* GroupingObjectsApiService Get all MACAddresses in a MACSet
  1729  List all MAC addresses in a MACSet
  1730  * @param ctx context.Context Authentication Context
  1731  @param macSetId MAC Set Id
  1732  @return manager.MacAddressElementListResult*/
  1733  func (a *GroupingObjectsApiService) GetMACAddresses(ctx context.Context, macSetId string) (manager.MacAddressElementListResult, *http.Response, error) {
  1734  	var (
  1735  		localVarHttpMethod = strings.ToUpper("Get")
  1736  		localVarPostBody   interface{}
  1737  		localVarFileName   string
  1738  		localVarFileBytes  []byte
  1739  		successPayload     manager.MacAddressElementListResult
  1740  	)
  1741  
  1742  	// create path and map variables
  1743  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}/members"
  1744  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -1)
  1745  
  1746  	localVarHeaderParams := make(map[string]string)
  1747  	localVarQueryParams := url.Values{}
  1748  	localVarFormParams := url.Values{}
  1749  
  1750  	// to determine the Content-Type header
  1751  	localVarHttpContentTypes := []string{"application/json"}
  1752  
  1753  	// set Content-Type header
  1754  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1755  	if localVarHttpContentType != "" {
  1756  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1757  	}
  1758  
  1759  	// to determine the Accept header
  1760  	localVarHttpHeaderAccepts := []string{
  1761  		"application/json",
  1762  	}
  1763  
  1764  	// set Accept header
  1765  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1766  	if localVarHttpHeaderAccept != "" {
  1767  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1768  	}
  1769  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1770  	if err != nil {
  1771  		return successPayload, nil, err
  1772  	}
  1773  
  1774  	localVarHttpResponse, err := a.client.callAPI(r)
  1775  	if err != nil || localVarHttpResponse == nil {
  1776  		return successPayload, localVarHttpResponse, err
  1777  	}
  1778  	defer localVarHttpResponse.Body.Close()
  1779  	if localVarHttpResponse.StatusCode >= 300 {
  1780  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1781  	}
  1782  
  1783  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1784  		return successPayload, localVarHttpResponse, err
  1785  	}
  1786  
  1787  	return successPayload, localVarHttpResponse, err
  1788  }
  1789  
  1790  /* GroupingObjectsApiService Get member types from NSGroup
  1791  Returns member types for a specified NSGroup including child NSGroups. This considers static members and members added via membership criteria only
  1792  * @param ctx context.Context Authentication Context
  1793  @param nsGroupId NSGroup Id
  1794  @param optional (nil or map[string]interface{}) with one or more of:
  1795      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1796      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1797      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1798      @param "sortAscending" (bool)
  1799      @param "sortBy" (string) Field by which records are sorted
  1800  @return manager.EffectiveMemberTypeListResult*/
  1801  func (a *GroupingObjectsApiService) GetMemberTypes(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.EffectiveMemberTypeListResult, *http.Response, error) {
  1802  	var (
  1803  		localVarHttpMethod = strings.ToUpper("Get")
  1804  		localVarPostBody   interface{}
  1805  		localVarFileName   string
  1806  		localVarFileBytes  []byte
  1807  		successPayload     manager.EffectiveMemberTypeListResult
  1808  	)
  1809  
  1810  	// create path and map variables
  1811  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}/member-types"
  1812  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  1813  
  1814  	localVarHeaderParams := make(map[string]string)
  1815  	localVarQueryParams := url.Values{}
  1816  	localVarFormParams := url.Values{}
  1817  
  1818  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1819  		return successPayload, nil, err
  1820  	}
  1821  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1822  		return successPayload, nil, err
  1823  	}
  1824  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1825  		return successPayload, nil, err
  1826  	}
  1827  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1828  		return successPayload, nil, err
  1829  	}
  1830  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1831  		return successPayload, nil, err
  1832  	}
  1833  
  1834  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1835  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1836  	}
  1837  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1838  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1839  	}
  1840  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1841  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1842  	}
  1843  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1844  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1845  	}
  1846  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1847  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1848  	}
  1849  	// to determine the Content-Type header
  1850  	localVarHttpContentTypes := []string{"application/json"}
  1851  
  1852  	// set Content-Type header
  1853  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1854  	if localVarHttpContentType != "" {
  1855  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1856  	}
  1857  
  1858  	// to determine the Accept header
  1859  	localVarHttpHeaderAccepts := []string{
  1860  		"application/json",
  1861  	}
  1862  
  1863  	// set Accept header
  1864  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1865  	if localVarHttpHeaderAccept != "" {
  1866  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1867  	}
  1868  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1869  	if err != nil {
  1870  		return successPayload, nil, err
  1871  	}
  1872  
  1873  	localVarHttpResponse, err := a.client.callAPI(r)
  1874  	if err != nil || localVarHttpResponse == nil {
  1875  		return successPayload, localVarHttpResponse, err
  1876  	}
  1877  	defer localVarHttpResponse.Body.Close()
  1878  	if localVarHttpResponse.StatusCode >= 300 {
  1879  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1880  	}
  1881  
  1882  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1883  		return successPayload, localVarHttpResponse, err
  1884  	}
  1885  
  1886  	return successPayload, localVarHttpResponse, err
  1887  }
  1888  
  1889  /* GroupingObjectsApiService Get services to which the given nsgroup belongs to
  1890  Returns information about services that are associated with the given NSGroup. The service name is passed by service_type parameter
  1891  * @param ctx context.Context Authentication Context
  1892  @param nsgroupId
  1893  @param serviceType
  1894  @param optional (nil or map[string]interface{}) with one or more of:
  1895      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  1896      @param "fetchParentgroupAssociations" (bool) Fetch complete list of associated resources considering nesting
  1897      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  1898      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  1899      @param "sortAscending" (bool)
  1900      @param "sortBy" (string) Field by which records are sorted
  1901  @return manager.ServiceAssociationListResult*/
  1902  func (a *GroupingObjectsApiService) GetServiceAssociations(ctx context.Context, nsgroupId string, serviceType string, localVarOptionals map[string]interface{}) (manager.ServiceAssociationListResult, *http.Response, error) {
  1903  	var (
  1904  		localVarHttpMethod = strings.ToUpper("Get")
  1905  		localVarPostBody   interface{}
  1906  		localVarFileName   string
  1907  		localVarFileBytes  []byte
  1908  		successPayload     manager.ServiceAssociationListResult
  1909  	)
  1910  
  1911  	// create path and map variables
  1912  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{nsgroup-id}/service-associations"
  1913  	localVarPath = strings.Replace(localVarPath, "{"+"nsgroup-id"+"}", fmt.Sprintf("%v", nsgroupId), -1)
  1914  
  1915  	localVarHeaderParams := make(map[string]string)
  1916  	localVarQueryParams := url.Values{}
  1917  	localVarFormParams := url.Values{}
  1918  
  1919  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  1920  		return successPayload, nil, err
  1921  	}
  1922  	if err := typeCheckParameter(localVarOptionals["fetchParentgroupAssociations"], "bool", "fetchParentgroupAssociations"); err != nil {
  1923  		return successPayload, nil, err
  1924  	}
  1925  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  1926  		return successPayload, nil, err
  1927  	}
  1928  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  1929  		return successPayload, nil, err
  1930  	}
  1931  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  1932  		return successPayload, nil, err
  1933  	}
  1934  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  1935  		return successPayload, nil, err
  1936  	}
  1937  
  1938  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  1939  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  1940  	}
  1941  	if localVarTempParam, localVarOk := localVarOptionals["fetchParentgroupAssociations"].(bool); localVarOk {
  1942  		localVarQueryParams.Add("fetch_parentgroup_associations", parameterToString(localVarTempParam, ""))
  1943  	}
  1944  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  1945  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  1946  	}
  1947  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  1948  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  1949  	}
  1950  	localVarQueryParams.Add("service_type", parameterToString(serviceType, ""))
  1951  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  1952  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  1953  	}
  1954  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  1955  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  1956  	}
  1957  	// to determine the Content-Type header
  1958  	localVarHttpContentTypes := []string{"application/json"}
  1959  
  1960  	// set Content-Type header
  1961  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  1962  	if localVarHttpContentType != "" {
  1963  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  1964  	}
  1965  
  1966  	// to determine the Accept header
  1967  	localVarHttpHeaderAccepts := []string{
  1968  		"application/json",
  1969  	}
  1970  
  1971  	// set Accept header
  1972  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  1973  	if localVarHttpHeaderAccept != "" {
  1974  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  1975  	}
  1976  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  1977  	if err != nil {
  1978  		return successPayload, nil, err
  1979  	}
  1980  
  1981  	localVarHttpResponse, err := a.client.callAPI(r)
  1982  	if err != nil || localVarHttpResponse == nil {
  1983  		return successPayload, localVarHttpResponse, err
  1984  	}
  1985  	defer localVarHttpResponse.Body.Close()
  1986  	if localVarHttpResponse.StatusCode >= 300 {
  1987  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  1988  	}
  1989  
  1990  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  1991  		return successPayload, localVarHttpResponse, err
  1992  	}
  1993  
  1994  	return successPayload, localVarHttpResponse, err
  1995  }
  1996  
  1997  /* GroupingObjectsApiService Get the list of all the virtual machines that are not a part of any existing NSGroup.
  1998  Get the list of all the virtual machines that are not a part of any existing NSGroup.
  1999  * @param ctx context.Context Authentication Context
  2000  @param optional (nil or map[string]interface{}) with one or more of:
  2001      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2002      @param "displayName" (string) Display Name of the virtual machine
  2003      @param "externalId" (string) External id of the virtual machine
  2004      @param "hostId" (string) Id of the host where this vif is located
  2005      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2006      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2007      @param "sortAscending" (bool)
  2008      @param "sortBy" (string) Field by which records are sorted
  2009  @return manager.UnassociatedVmListResult*/
  2010  func (a *GroupingObjectsApiService) GetUnassociatedVirtualMachines(ctx context.Context, localVarOptionals map[string]interface{}) (manager.UnassociatedVmListResult, *http.Response, error) {
  2011  	var (
  2012  		localVarHttpMethod = strings.ToUpper("Get")
  2013  		localVarPostBody   interface{}
  2014  		localVarFileName   string
  2015  		localVarFileBytes  []byte
  2016  		successPayload     manager.UnassociatedVmListResult
  2017  	)
  2018  
  2019  	// create path and map variables
  2020  	localVarPath := a.client.cfg.BasePath + "/ns-groups/unassociated-virtual-machines"
  2021  
  2022  	localVarHeaderParams := make(map[string]string)
  2023  	localVarQueryParams := url.Values{}
  2024  	localVarFormParams := url.Values{}
  2025  
  2026  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2027  		return successPayload, nil, err
  2028  	}
  2029  	if err := typeCheckParameter(localVarOptionals["displayName"], "string", "displayName"); err != nil {
  2030  		return successPayload, nil, err
  2031  	}
  2032  	if err := typeCheckParameter(localVarOptionals["externalId"], "string", "externalId"); err != nil {
  2033  		return successPayload, nil, err
  2034  	}
  2035  	if err := typeCheckParameter(localVarOptionals["hostId"], "string", "hostId"); err != nil {
  2036  		return successPayload, nil, err
  2037  	}
  2038  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2039  		return successPayload, nil, err
  2040  	}
  2041  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2042  		return successPayload, nil, err
  2043  	}
  2044  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2045  		return successPayload, nil, err
  2046  	}
  2047  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2048  		return successPayload, nil, err
  2049  	}
  2050  
  2051  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2052  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2053  	}
  2054  	if localVarTempParam, localVarOk := localVarOptionals["displayName"].(string); localVarOk {
  2055  		localVarQueryParams.Add("display_name", parameterToString(localVarTempParam, ""))
  2056  	}
  2057  	if localVarTempParam, localVarOk := localVarOptionals["externalId"].(string); localVarOk {
  2058  		localVarQueryParams.Add("external_id", parameterToString(localVarTempParam, ""))
  2059  	}
  2060  	if localVarTempParam, localVarOk := localVarOptionals["hostId"].(string); localVarOk {
  2061  		localVarQueryParams.Add("host_id", parameterToString(localVarTempParam, ""))
  2062  	}
  2063  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2064  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2065  	}
  2066  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2067  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2068  	}
  2069  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2070  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2071  	}
  2072  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2073  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2074  	}
  2075  	// to determine the Content-Type header
  2076  	localVarHttpContentTypes := []string{"application/json"}
  2077  
  2078  	// set Content-Type header
  2079  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2080  	if localVarHttpContentType != "" {
  2081  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2082  	}
  2083  
  2084  	// to determine the Accept header
  2085  	localVarHttpHeaderAccepts := []string{
  2086  		"application/json",
  2087  	}
  2088  
  2089  	// set Accept header
  2090  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2091  	if localVarHttpHeaderAccept != "" {
  2092  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2093  	}
  2094  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2095  	if err != nil {
  2096  		return successPayload, nil, err
  2097  	}
  2098  
  2099  	localVarHttpResponse, err := a.client.callAPI(r)
  2100  	if err != nil || localVarHttpResponse == nil {
  2101  		return successPayload, localVarHttpResponse, err
  2102  	}
  2103  	defer localVarHttpResponse.Body.Close()
  2104  	if localVarHttpResponse.StatusCode >= 300 {
  2105  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2106  	}
  2107  
  2108  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2109  		return successPayload, localVarHttpResponse, err
  2110  	}
  2111  
  2112  	return successPayload, localVarHttpResponse, err
  2113  }
  2114  
  2115  /* GroupingObjectsApiService List IPSets
  2116  Returns paginated list of IPSets
  2117  * @param ctx context.Context Authentication Context
  2118  @param optional (nil or map[string]interface{}) with one or more of:
  2119      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2120      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2121      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2122      @param "sortAscending" (bool)
  2123      @param "sortBy" (string) Field by which records are sorted
  2124  @return manager.IpSetListResult*/
  2125  func (a *GroupingObjectsApiService) ListIPSets(ctx context.Context, localVarOptionals map[string]interface{}) (manager.IpSetListResult, *http.Response, error) {
  2126  	var (
  2127  		localVarHttpMethod = strings.ToUpper("Get")
  2128  		localVarPostBody   interface{}
  2129  		localVarFileName   string
  2130  		localVarFileBytes  []byte
  2131  		successPayload     manager.IpSetListResult
  2132  	)
  2133  
  2134  	// create path and map variables
  2135  	localVarPath := a.client.cfg.BasePath + "/ip-sets"
  2136  
  2137  	localVarHeaderParams := make(map[string]string)
  2138  	localVarQueryParams := url.Values{}
  2139  	localVarFormParams := url.Values{}
  2140  
  2141  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2142  		return successPayload, nil, err
  2143  	}
  2144  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2145  		return successPayload, nil, err
  2146  	}
  2147  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2148  		return successPayload, nil, err
  2149  	}
  2150  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2151  		return successPayload, nil, err
  2152  	}
  2153  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2154  		return successPayload, nil, err
  2155  	}
  2156  
  2157  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2158  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2159  	}
  2160  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2161  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2162  	}
  2163  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2164  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2165  	}
  2166  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2167  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2168  	}
  2169  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2170  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2171  	}
  2172  	// to determine the Content-Type header
  2173  	localVarHttpContentTypes := []string{"application/json"}
  2174  
  2175  	// set Content-Type header
  2176  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2177  	if localVarHttpContentType != "" {
  2178  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2179  	}
  2180  
  2181  	// to determine the Accept header
  2182  	localVarHttpHeaderAccepts := []string{
  2183  		"application/json",
  2184  	}
  2185  
  2186  	// set Accept header
  2187  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2188  	if localVarHttpHeaderAccept != "" {
  2189  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2190  	}
  2191  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2192  	if err != nil {
  2193  		return successPayload, nil, err
  2194  	}
  2195  
  2196  	localVarHttpResponse, err := a.client.callAPI(r)
  2197  	if err != nil || localVarHttpResponse == nil {
  2198  		return successPayload, localVarHttpResponse, err
  2199  	}
  2200  	defer localVarHttpResponse.Body.Close()
  2201  	if localVarHttpResponse.StatusCode >= 300 {
  2202  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2203  	}
  2204  
  2205  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2206  		return successPayload, localVarHttpResponse, err
  2207  	}
  2208  
  2209  	return successPayload, localVarHttpResponse, err
  2210  }
  2211  
  2212  /* GroupingObjectsApiService List MACSets
  2213  Returns paginated list of MACSets
  2214  * @param ctx context.Context Authentication Context
  2215  @param optional (nil or map[string]interface{}) with one or more of:
  2216      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2217      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2218      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2219      @param "sortAscending" (bool)
  2220      @param "sortBy" (string) Field by which records are sorted
  2221  @return manager.MacSetListResult*/
  2222  func (a *GroupingObjectsApiService) ListMACSets(ctx context.Context, localVarOptionals map[string]interface{}) (manager.MacSetListResult, *http.Response, error) {
  2223  	var (
  2224  		localVarHttpMethod = strings.ToUpper("Get")
  2225  		localVarPostBody   interface{}
  2226  		localVarFileName   string
  2227  		localVarFileBytes  []byte
  2228  		successPayload     manager.MacSetListResult
  2229  	)
  2230  
  2231  	// create path and map variables
  2232  	localVarPath := a.client.cfg.BasePath + "/mac-sets"
  2233  
  2234  	localVarHeaderParams := make(map[string]string)
  2235  	localVarQueryParams := url.Values{}
  2236  	localVarFormParams := url.Values{}
  2237  
  2238  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2239  		return successPayload, nil, err
  2240  	}
  2241  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2242  		return successPayload, nil, err
  2243  	}
  2244  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2245  		return successPayload, nil, err
  2246  	}
  2247  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2248  		return successPayload, nil, err
  2249  	}
  2250  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2251  		return successPayload, nil, err
  2252  	}
  2253  
  2254  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2255  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2256  	}
  2257  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2258  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2259  	}
  2260  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2261  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2262  	}
  2263  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2264  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2265  	}
  2266  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2267  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2268  	}
  2269  	// to determine the Content-Type header
  2270  	localVarHttpContentTypes := []string{"application/json"}
  2271  
  2272  	// set Content-Type header
  2273  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2274  	if localVarHttpContentType != "" {
  2275  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2276  	}
  2277  
  2278  	// to determine the Accept header
  2279  	localVarHttpHeaderAccepts := []string{
  2280  		"application/json",
  2281  	}
  2282  
  2283  	// set Accept header
  2284  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2285  	if localVarHttpHeaderAccept != "" {
  2286  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2287  	}
  2288  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2289  	if err != nil {
  2290  		return successPayload, nil, err
  2291  	}
  2292  
  2293  	localVarHttpResponse, err := a.client.callAPI(r)
  2294  	if err != nil || localVarHttpResponse == nil {
  2295  		return successPayload, localVarHttpResponse, err
  2296  	}
  2297  	defer localVarHttpResponse.Body.Close()
  2298  	if localVarHttpResponse.StatusCode >= 300 {
  2299  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2300  	}
  2301  
  2302  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2303  		return successPayload, localVarHttpResponse, err
  2304  	}
  2305  
  2306  	return successPayload, localVarHttpResponse, err
  2307  }
  2308  
  2309  /* GroupingObjectsApiService List NSGroups
  2310  List the NSGroups in a paginated format. The page size is restricted to 50 NSGroups so that the size of the response remains small even in the worst case. Optionally, specify valid member types as request parameter to filter NSGroups.
  2311  * @param ctx context.Context Authentication Context
  2312  @param optional (nil or map[string]interface{}) with one or more of:
  2313      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2314      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2315      @param "memberTypes" (string) Specify member types to filter corresponding NSGroups
  2316      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2317      @param "populateReferences" (bool) Populate metadata of resource referenced by NSGroupExpressions
  2318      @param "sortAscending" (bool)
  2319      @param "sortBy" (string) Field by which records are sorted
  2320  @return manager.NsGroupListResult*/
  2321  func (a *GroupingObjectsApiService) ListNSGroups(ctx context.Context, localVarOptionals map[string]interface{}) (manager.NsGroupListResult, *http.Response, error) {
  2322  	var (
  2323  		localVarHttpMethod = strings.ToUpper("Get")
  2324  		localVarPostBody   interface{}
  2325  		localVarFileName   string
  2326  		localVarFileBytes  []byte
  2327  		successPayload     manager.NsGroupListResult
  2328  	)
  2329  
  2330  	// create path and map variables
  2331  	localVarPath := a.client.cfg.BasePath + "/ns-groups"
  2332  
  2333  	localVarHeaderParams := make(map[string]string)
  2334  	localVarQueryParams := url.Values{}
  2335  	localVarFormParams := url.Values{}
  2336  
  2337  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2338  		return successPayload, nil, err
  2339  	}
  2340  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2341  		return successPayload, nil, err
  2342  	}
  2343  	if err := typeCheckParameter(localVarOptionals["memberTypes"], "string", "memberTypes"); err != nil {
  2344  		return successPayload, nil, err
  2345  	}
  2346  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2347  		return successPayload, nil, err
  2348  	}
  2349  	if err := typeCheckParameter(localVarOptionals["populateReferences"], "bool", "populateReferences"); err != nil {
  2350  		return successPayload, nil, err
  2351  	}
  2352  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2353  		return successPayload, nil, err
  2354  	}
  2355  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2356  		return successPayload, nil, err
  2357  	}
  2358  
  2359  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2360  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2361  	}
  2362  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2363  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2364  	}
  2365  	if localVarTempParam, localVarOk := localVarOptionals["memberTypes"].(string); localVarOk {
  2366  		localVarQueryParams.Add("member_types", parameterToString(localVarTempParam, ""))
  2367  	}
  2368  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2369  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2370  	}
  2371  	if localVarTempParam, localVarOk := localVarOptionals["populateReferences"].(bool); localVarOk {
  2372  		localVarQueryParams.Add("populate_references", parameterToString(localVarTempParam, ""))
  2373  	}
  2374  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2375  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2376  	}
  2377  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2378  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2379  	}
  2380  	// to determine the Content-Type header
  2381  	localVarHttpContentTypes := []string{"application/json"}
  2382  
  2383  	// set Content-Type header
  2384  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2385  	if localVarHttpContentType != "" {
  2386  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2387  	}
  2388  
  2389  	// to determine the Accept header
  2390  	localVarHttpHeaderAccepts := []string{
  2391  		"application/json",
  2392  	}
  2393  
  2394  	// set Accept header
  2395  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2396  	if localVarHttpHeaderAccept != "" {
  2397  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2398  	}
  2399  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2400  	if err != nil {
  2401  		return successPayload, nil, err
  2402  	}
  2403  
  2404  	localVarHttpResponse, err := a.client.callAPI(r)
  2405  	if err != nil || localVarHttpResponse == nil {
  2406  		return successPayload, localVarHttpResponse, err
  2407  	}
  2408  	defer localVarHttpResponse.Body.Close()
  2409  	if localVarHttpResponse.StatusCode >= 300 {
  2410  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2411  	}
  2412  
  2413  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2414  		return successPayload, localVarHttpResponse, err
  2415  	}
  2416  
  2417  	return successPayload, localVarHttpResponse, err
  2418  }
  2419  
  2420  /* GroupingObjectsApiService List all NSServiceGroups
  2421  Returns paginated list of NSServiceGroups
  2422  * @param ctx context.Context Authentication Context
  2423  @param optional (nil or map[string]interface{}) with one or more of:
  2424      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2425      @param "defaultService" (bool) Fetch all default NSServiceGroups
  2426      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2427      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2428      @param "sortAscending" (bool)
  2429      @param "sortBy" (string) Field by which records are sorted
  2430  @return manager.NsServiceGroupListResult*/
  2431  func (a *GroupingObjectsApiService) ListNSServiceGroups(ctx context.Context, localVarOptionals map[string]interface{}) (manager.NsServiceGroupListResult, *http.Response, error) {
  2432  	var (
  2433  		localVarHttpMethod = strings.ToUpper("Get")
  2434  		localVarPostBody   interface{}
  2435  		localVarFileName   string
  2436  		localVarFileBytes  []byte
  2437  		successPayload     manager.NsServiceGroupListResult
  2438  	)
  2439  
  2440  	// create path and map variables
  2441  	localVarPath := a.client.cfg.BasePath + "/ns-service-groups"
  2442  
  2443  	localVarHeaderParams := make(map[string]string)
  2444  	localVarQueryParams := url.Values{}
  2445  	localVarFormParams := url.Values{}
  2446  
  2447  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2448  		return successPayload, nil, err
  2449  	}
  2450  	if err := typeCheckParameter(localVarOptionals["defaultService"], "bool", "defaultService"); err != nil {
  2451  		return successPayload, nil, err
  2452  	}
  2453  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2454  		return successPayload, nil, err
  2455  	}
  2456  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2457  		return successPayload, nil, err
  2458  	}
  2459  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2460  		return successPayload, nil, err
  2461  	}
  2462  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2463  		return successPayload, nil, err
  2464  	}
  2465  
  2466  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2467  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2468  	}
  2469  	if localVarTempParam, localVarOk := localVarOptionals["defaultService"].(bool); localVarOk {
  2470  		localVarQueryParams.Add("default_service", parameterToString(localVarTempParam, ""))
  2471  	}
  2472  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2473  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2474  	}
  2475  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2476  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2477  	}
  2478  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2479  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2480  	}
  2481  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2482  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2483  	}
  2484  	// to determine the Content-Type header
  2485  	localVarHttpContentTypes := []string{"application/json"}
  2486  
  2487  	// set Content-Type header
  2488  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2489  	if localVarHttpContentType != "" {
  2490  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2491  	}
  2492  
  2493  	// to determine the Accept header
  2494  	localVarHttpHeaderAccepts := []string{
  2495  		"application/json",
  2496  	}
  2497  
  2498  	// set Accept header
  2499  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2500  	if localVarHttpHeaderAccept != "" {
  2501  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2502  	}
  2503  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2504  	if err != nil {
  2505  		return successPayload, nil, err
  2506  	}
  2507  
  2508  	localVarHttpResponse, err := a.client.callAPI(r)
  2509  	if err != nil || localVarHttpResponse == nil {
  2510  		return successPayload, localVarHttpResponse, err
  2511  	}
  2512  	defer localVarHttpResponse.Body.Close()
  2513  	if localVarHttpResponse.StatusCode >= 300 {
  2514  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2515  	}
  2516  
  2517  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2518  		return successPayload, localVarHttpResponse, err
  2519  	}
  2520  
  2521  	return successPayload, localVarHttpResponse, err
  2522  }
  2523  
  2524  /* GroupingObjectsApiService List all NSServices
  2525  Returns paginated list of NSServices
  2526  * @param ctx context.Context Authentication Context
  2527  @param optional (nil or map[string]interface{}) with one or more of:
  2528      @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page)
  2529      @param "defaultService" (bool) Fetch all default NSServices
  2530      @param "includedFields" (string) Comma separated list of fields that should be included to result of query
  2531      @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer)
  2532      @param "sortAscending" (bool)
  2533      @param "sortBy" (string) Field by which records are sorted
  2534  @return manager.NsServiceListResult*/
  2535  func (a *GroupingObjectsApiService) ListNSServices(ctx context.Context, localVarOptionals map[string]interface{}) (manager.NsServiceListResult, *http.Response, error) {
  2536  	var (
  2537  		localVarHttpMethod = strings.ToUpper("Get")
  2538  		localVarPostBody   interface{}
  2539  		localVarFileName   string
  2540  		localVarFileBytes  []byte
  2541  		successPayload     manager.NsServiceListResult
  2542  	)
  2543  
  2544  	// create path and map variables
  2545  	localVarPath := a.client.cfg.BasePath + "/ns-services"
  2546  
  2547  	localVarHeaderParams := make(map[string]string)
  2548  	localVarQueryParams := url.Values{}
  2549  	localVarFormParams := url.Values{}
  2550  
  2551  	if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil {
  2552  		return successPayload, nil, err
  2553  	}
  2554  	if err := typeCheckParameter(localVarOptionals["defaultService"], "bool", "defaultService"); err != nil {
  2555  		return successPayload, nil, err
  2556  	}
  2557  	if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil {
  2558  		return successPayload, nil, err
  2559  	}
  2560  	if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil {
  2561  		return successPayload, nil, err
  2562  	}
  2563  	if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil {
  2564  		return successPayload, nil, err
  2565  	}
  2566  	if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil {
  2567  		return successPayload, nil, err
  2568  	}
  2569  
  2570  	if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk {
  2571  		localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, ""))
  2572  	}
  2573  	if localVarTempParam, localVarOk := localVarOptionals["defaultService"].(bool); localVarOk {
  2574  		localVarQueryParams.Add("default_service", parameterToString(localVarTempParam, ""))
  2575  	}
  2576  	if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk {
  2577  		localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, ""))
  2578  	}
  2579  	if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk {
  2580  		localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, ""))
  2581  	}
  2582  	if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk {
  2583  		localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, ""))
  2584  	}
  2585  	if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk {
  2586  		localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, ""))
  2587  	}
  2588  	// to determine the Content-Type header
  2589  	localVarHttpContentTypes := []string{"application/json"}
  2590  
  2591  	// set Content-Type header
  2592  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2593  	if localVarHttpContentType != "" {
  2594  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2595  	}
  2596  
  2597  	// to determine the Accept header
  2598  	localVarHttpHeaderAccepts := []string{
  2599  		"application/json",
  2600  	}
  2601  
  2602  	// set Accept header
  2603  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2604  	if localVarHttpHeaderAccept != "" {
  2605  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2606  	}
  2607  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2608  	if err != nil {
  2609  		return successPayload, nil, err
  2610  	}
  2611  
  2612  	localVarHttpResponse, err := a.client.callAPI(r)
  2613  	if err != nil || localVarHttpResponse == nil {
  2614  		return successPayload, localVarHttpResponse, err
  2615  	}
  2616  	defer localVarHttpResponse.Body.Close()
  2617  	if localVarHttpResponse.StatusCode >= 300 {
  2618  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2619  	}
  2620  
  2621  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2622  		return successPayload, localVarHttpResponse, err
  2623  	}
  2624  
  2625  	return successPayload, localVarHttpResponse, err
  2626  }
  2627  
  2628  /* GroupingObjectsApiService Read IPSet
  2629  Returns information about the specified IPSet
  2630  * @param ctx context.Context Authentication Context
  2631  @param ipSetId IPSet Id
  2632  @return manager.IpSet*/
  2633  func (a *GroupingObjectsApiService) ReadIPSet(ctx context.Context, ipSetId string) (manager.IpSet, *http.Response, error) {
  2634  	var (
  2635  		localVarHttpMethod = strings.ToUpper("Get")
  2636  		localVarPostBody   interface{}
  2637  		localVarFileName   string
  2638  		localVarFileBytes  []byte
  2639  		successPayload     manager.IpSet
  2640  	)
  2641  
  2642  	// create path and map variables
  2643  	localVarPath := a.client.cfg.BasePath + "/ip-sets/{ip-set-id}"
  2644  	localVarPath = strings.Replace(localVarPath, "{"+"ip-set-id"+"}", fmt.Sprintf("%v", ipSetId), -1)
  2645  
  2646  	localVarHeaderParams := make(map[string]string)
  2647  	localVarQueryParams := url.Values{}
  2648  	localVarFormParams := url.Values{}
  2649  
  2650  	// to determine the Content-Type header
  2651  	localVarHttpContentTypes := []string{"application/json"}
  2652  
  2653  	// set Content-Type header
  2654  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2655  	if localVarHttpContentType != "" {
  2656  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2657  	}
  2658  
  2659  	// to determine the Accept header
  2660  	localVarHttpHeaderAccepts := []string{
  2661  		"application/json",
  2662  	}
  2663  
  2664  	// set Accept header
  2665  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2666  	if localVarHttpHeaderAccept != "" {
  2667  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2668  	}
  2669  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2670  	if err != nil {
  2671  		return successPayload, nil, err
  2672  	}
  2673  
  2674  	localVarHttpResponse, err := a.client.callAPI(r)
  2675  	if err != nil || localVarHttpResponse == nil {
  2676  		return successPayload, localVarHttpResponse, err
  2677  	}
  2678  	defer localVarHttpResponse.Body.Close()
  2679  	if localVarHttpResponse.StatusCode >= 300 {
  2680  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2681  	}
  2682  
  2683  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2684  		return successPayload, localVarHttpResponse, err
  2685  	}
  2686  
  2687  	return successPayload, localVarHttpResponse, err
  2688  }
  2689  
  2690  /* GroupingObjectsApiService Read MACSet
  2691  Returns information about the specified MACSet
  2692  * @param ctx context.Context Authentication Context
  2693  @param macSetId MACSet Id
  2694  @return manager.MacSet*/
  2695  func (a *GroupingObjectsApiService) ReadMACSet(ctx context.Context, macSetId string) (manager.MacSet, *http.Response, error) {
  2696  	var (
  2697  		localVarHttpMethod = strings.ToUpper("Get")
  2698  		localVarPostBody   interface{}
  2699  		localVarFileName   string
  2700  		localVarFileBytes  []byte
  2701  		successPayload     manager.MacSet
  2702  	)
  2703  
  2704  	// create path and map variables
  2705  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}"
  2706  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -1)
  2707  
  2708  	localVarHeaderParams := make(map[string]string)
  2709  	localVarQueryParams := url.Values{}
  2710  	localVarFormParams := url.Values{}
  2711  
  2712  	// to determine the Content-Type header
  2713  	localVarHttpContentTypes := []string{"application/json"}
  2714  
  2715  	// set Content-Type header
  2716  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2717  	if localVarHttpContentType != "" {
  2718  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2719  	}
  2720  
  2721  	// to determine the Accept header
  2722  	localVarHttpHeaderAccepts := []string{
  2723  		"application/json",
  2724  	}
  2725  
  2726  	// set Accept header
  2727  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2728  	if localVarHttpHeaderAccept != "" {
  2729  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2730  	}
  2731  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2732  	if err != nil {
  2733  		return successPayload, nil, err
  2734  	}
  2735  
  2736  	localVarHttpResponse, err := a.client.callAPI(r)
  2737  	if err != nil || localVarHttpResponse == nil {
  2738  		return successPayload, localVarHttpResponse, err
  2739  	}
  2740  	defer localVarHttpResponse.Body.Close()
  2741  	if localVarHttpResponse.StatusCode >= 300 {
  2742  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2743  	}
  2744  
  2745  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2746  		return successPayload, localVarHttpResponse, err
  2747  	}
  2748  
  2749  	return successPayload, localVarHttpResponse, err
  2750  }
  2751  
  2752  /* GroupingObjectsApiService Read NSGroup
  2753  Returns information about the specified NSGroup.
  2754  * @param ctx context.Context Authentication Context
  2755  @param nsGroupId NSGroup Id
  2756  @param optional (nil or map[string]interface{}) with one or more of:
  2757      @param "populateReferences" (bool) Populate metadata of resource referenced by NSGroupExpressions
  2758  @return NsGroup*/
  2759  func (a *GroupingObjectsApiService) ReadNSGroup(ctx context.Context, nsGroupId string, localVarOptionals map[string]interface{}) (manager.NsGroup, *http.Response, error) {
  2760  	var (
  2761  		localVarHttpMethod = strings.ToUpper("Get")
  2762  		localVarPostBody   interface{}
  2763  		localVarFileName   string
  2764  		localVarFileBytes  []byte
  2765  		successPayload     manager.NsGroup
  2766  	)
  2767  
  2768  	// create path and map variables
  2769  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
  2770  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  2771  
  2772  	localVarHeaderParams := make(map[string]string)
  2773  	localVarQueryParams := url.Values{}
  2774  	localVarFormParams := url.Values{}
  2775  
  2776  	if err := typeCheckParameter(localVarOptionals["populateReferences"], "bool", "populateReferences"); err != nil {
  2777  		return successPayload, nil, err
  2778  	}
  2779  
  2780  	if localVarTempParam, localVarOk := localVarOptionals["populateReferences"].(bool); localVarOk {
  2781  		localVarQueryParams.Add("populate_references", parameterToString(localVarTempParam, ""))
  2782  	}
  2783  	// to determine the Content-Type header
  2784  	localVarHttpContentTypes := []string{"application/json"}
  2785  
  2786  	// set Content-Type header
  2787  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2788  	if localVarHttpContentType != "" {
  2789  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2790  	}
  2791  
  2792  	// to determine the Accept header
  2793  	localVarHttpHeaderAccepts := []string{
  2794  		"application/json",
  2795  	}
  2796  
  2797  	// set Accept header
  2798  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2799  	if localVarHttpHeaderAccept != "" {
  2800  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2801  	}
  2802  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2803  	if err != nil {
  2804  		return successPayload, nil, err
  2805  	}
  2806  
  2807  	localVarHttpResponse, err := a.client.callAPI(r)
  2808  	if err != nil || localVarHttpResponse == nil {
  2809  		return successPayload, localVarHttpResponse, err
  2810  	}
  2811  	defer localVarHttpResponse.Body.Close()
  2812  	if localVarHttpResponse.StatusCode >= 300 {
  2813  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2814  	}
  2815  
  2816  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2817  		return successPayload, localVarHttpResponse, err
  2818  	}
  2819  
  2820  	return successPayload, localVarHttpResponse, err
  2821  }
  2822  
  2823  /* GroupingObjectsApiService Read NSService
  2824  Returns information about the specified NSService
  2825  * @param ctx context.Context Authentication Context
  2826  @param nsServiceId NSService Id
  2827  @return manager.NsService*/
  2828  func (a *GroupingObjectsApiService) ReadNSService(ctx context.Context, nsServiceId string) (manager.NsService, *http.Response, error) {
  2829  	var (
  2830  		localVarHttpMethod = strings.ToUpper("Get")
  2831  		localVarPostBody   interface{}
  2832  		localVarFileName   string
  2833  		localVarFileBytes  []byte
  2834  		successPayload     manager.NsService
  2835  	)
  2836  
  2837  	// create path and map variables
  2838  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  2839  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  2840  
  2841  	localVarHeaderParams := make(map[string]string)
  2842  	localVarQueryParams := url.Values{}
  2843  	localVarFormParams := url.Values{}
  2844  
  2845  	// to determine the Content-Type header
  2846  	localVarHttpContentTypes := []string{"application/json"}
  2847  
  2848  	// set Content-Type header
  2849  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2850  	if localVarHttpContentType != "" {
  2851  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2852  	}
  2853  
  2854  	// to determine the Accept header
  2855  	localVarHttpHeaderAccepts := []string{
  2856  		"application/json",
  2857  	}
  2858  
  2859  	// set Accept header
  2860  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2861  	if localVarHttpHeaderAccept != "" {
  2862  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2863  	}
  2864  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2865  	if err != nil {
  2866  		return successPayload, nil, err
  2867  	}
  2868  
  2869  	localVarHttpResponse, err := a.client.callAPI(r)
  2870  	if err != nil || localVarHttpResponse == nil {
  2871  		return successPayload, localVarHttpResponse, err
  2872  	}
  2873  	defer localVarHttpResponse.Body.Close()
  2874  	if localVarHttpResponse.StatusCode >= 300 {
  2875  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2876  	}
  2877  
  2878  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2879  		return successPayload, localVarHttpResponse, err
  2880  	}
  2881  
  2882  	return successPayload, localVarHttpResponse, err
  2883  }
  2884  
  2885  /* GroupingObjectsApiService Read L4PortSetNSService
  2886  Returns information about the specified L4PortSetNSService
  2887  * @param ctx context.Context Authentication Context
  2888  @param nsServiceId NSService Id
  2889  @return manager.L4PortSetNsService*/
  2890  func (a *GroupingObjectsApiService) ReadL4PortSetNSService(ctx context.Context, nsServiceId string) (manager.L4PortSetNsService, *http.Response, error) {
  2891  	var (
  2892  		localVarHttpMethod = strings.ToUpper("Get")
  2893  		localVarPostBody   interface{}
  2894  		localVarFileName   string
  2895  		localVarFileBytes  []byte
  2896  		successPayload     manager.L4PortSetNsService
  2897  	)
  2898  
  2899  	// create path and map variables
  2900  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  2901  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  2902  
  2903  	localVarHeaderParams := make(map[string]string)
  2904  	localVarQueryParams := url.Values{}
  2905  	localVarFormParams := url.Values{}
  2906  
  2907  	// to determine the Content-Type header
  2908  	localVarHttpContentTypes := []string{"application/json"}
  2909  
  2910  	// set Content-Type header
  2911  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2912  	if localVarHttpContentType != "" {
  2913  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2914  	}
  2915  
  2916  	// to determine the Accept header
  2917  	localVarHttpHeaderAccepts := []string{
  2918  		"application/json",
  2919  	}
  2920  
  2921  	// set Accept header
  2922  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2923  	if localVarHttpHeaderAccept != "" {
  2924  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2925  	}
  2926  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2927  	if err != nil {
  2928  		return successPayload, nil, err
  2929  	}
  2930  
  2931  	localVarHttpResponse, err := a.client.callAPI(r)
  2932  	if err != nil || localVarHttpResponse == nil {
  2933  		return successPayload, localVarHttpResponse, err
  2934  	}
  2935  	defer localVarHttpResponse.Body.Close()
  2936  	if localVarHttpResponse.StatusCode >= 300 {
  2937  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  2938  	}
  2939  
  2940  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  2941  		return successPayload, localVarHttpResponse, err
  2942  	}
  2943  
  2944  	return successPayload, localVarHttpResponse, err
  2945  }
  2946  
  2947  /* GroupingObjectsApiService Read IcmpTypeNSService
  2948  Returns information about the specified IcmpTypeNSService
  2949  * @param ctx context.Context Authentication Context
  2950  @param nsServiceId NSService Id
  2951  @return manager.IcmpTypeNsService*/
  2952  func (a *GroupingObjectsApiService) ReadIcmpTypeNSService(ctx context.Context, nsServiceId string) (manager.IcmpTypeNsService, *http.Response, error) {
  2953  	var (
  2954  		localVarHttpMethod = strings.ToUpper("Get")
  2955  		localVarPostBody   interface{}
  2956  		localVarFileName   string
  2957  		localVarFileBytes  []byte
  2958  		successPayload     manager.IcmpTypeNsService
  2959  	)
  2960  
  2961  	// create path and map variables
  2962  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  2963  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  2964  
  2965  	localVarHeaderParams := make(map[string]string)
  2966  	localVarQueryParams := url.Values{}
  2967  	localVarFormParams := url.Values{}
  2968  
  2969  	// to determine the Content-Type header
  2970  	localVarHttpContentTypes := []string{"application/json"}
  2971  
  2972  	// set Content-Type header
  2973  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  2974  	if localVarHttpContentType != "" {
  2975  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  2976  	}
  2977  
  2978  	// to determine the Accept header
  2979  	localVarHttpHeaderAccepts := []string{
  2980  		"application/json",
  2981  	}
  2982  
  2983  	// set Accept header
  2984  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  2985  	if localVarHttpHeaderAccept != "" {
  2986  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  2987  	}
  2988  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  2989  	if err != nil {
  2990  		return successPayload, nil, err
  2991  	}
  2992  
  2993  	localVarHttpResponse, err := a.client.callAPI(r)
  2994  	if err != nil || localVarHttpResponse == nil {
  2995  		return successPayload, localVarHttpResponse, err
  2996  	}
  2997  	defer localVarHttpResponse.Body.Close()
  2998  	if localVarHttpResponse.StatusCode >= 300 {
  2999  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3000  	}
  3001  
  3002  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3003  		return successPayload, localVarHttpResponse, err
  3004  	}
  3005  
  3006  	return successPayload, localVarHttpResponse, err
  3007  }
  3008  
  3009  /* GroupingObjectsApiService Read IgmpTypeNSService
  3010  Returns information about the specified IgmpTypeNSService
  3011  * @param ctx context.Context Authentication Context
  3012  @param nsServiceId NSService Id
  3013  @return manager.IgmpTypeNsService*/
  3014  func (a *GroupingObjectsApiService) ReadIgmpTypeNSService(ctx context.Context, nsServiceId string) (manager.IgmpTypeNsService, *http.Response, error) {
  3015  	var (
  3016  		localVarHttpMethod = strings.ToUpper("Get")
  3017  		localVarPostBody   interface{}
  3018  		localVarFileName   string
  3019  		localVarFileBytes  []byte
  3020  		successPayload     manager.IgmpTypeNsService
  3021  	)
  3022  
  3023  	// create path and map variables
  3024  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3025  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3026  
  3027  	localVarHeaderParams := make(map[string]string)
  3028  	localVarQueryParams := url.Values{}
  3029  	localVarFormParams := url.Values{}
  3030  
  3031  	// to determine the Content-Type header
  3032  	localVarHttpContentTypes := []string{"application/json"}
  3033  
  3034  	// set Content-Type header
  3035  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3036  	if localVarHttpContentType != "" {
  3037  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3038  	}
  3039  
  3040  	// to determine the Accept header
  3041  	localVarHttpHeaderAccepts := []string{
  3042  		"application/json",
  3043  	}
  3044  
  3045  	// set Accept header
  3046  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3047  	if localVarHttpHeaderAccept != "" {
  3048  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3049  	}
  3050  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3051  	if err != nil {
  3052  		return successPayload, nil, err
  3053  	}
  3054  
  3055  	localVarHttpResponse, err := a.client.callAPI(r)
  3056  	if err != nil || localVarHttpResponse == nil {
  3057  		return successPayload, localVarHttpResponse, err
  3058  	}
  3059  	defer localVarHttpResponse.Body.Close()
  3060  	if localVarHttpResponse.StatusCode >= 300 {
  3061  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3062  	}
  3063  
  3064  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3065  		return successPayload, localVarHttpResponse, err
  3066  	}
  3067  
  3068  	return successPayload, localVarHttpResponse, err
  3069  }
  3070  
  3071  /* GroupingObjectsApiService Read AlgTypeNSService
  3072  Returns information about the specified AlgTypeNSService
  3073  * @param ctx context.Context Authentication Context
  3074  @param nsServiceId NSService Id
  3075  @return manager.AlgTypeNsService*/
  3076  func (a *GroupingObjectsApiService) ReadAlgTypeNSService(ctx context.Context, nsServiceId string) (manager.AlgTypeNsService, *http.Response, error) {
  3077  	var (
  3078  		localVarHttpMethod = strings.ToUpper("Get")
  3079  		localVarPostBody   interface{}
  3080  		localVarFileName   string
  3081  		localVarFileBytes  []byte
  3082  		successPayload     manager.AlgTypeNsService
  3083  	)
  3084  
  3085  	// create path and map variables
  3086  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3087  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3088  
  3089  	localVarHeaderParams := make(map[string]string)
  3090  	localVarQueryParams := url.Values{}
  3091  	localVarFormParams := url.Values{}
  3092  
  3093  	// to determine the Content-Type header
  3094  	localVarHttpContentTypes := []string{"application/json"}
  3095  
  3096  	// set Content-Type header
  3097  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3098  	if localVarHttpContentType != "" {
  3099  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3100  	}
  3101  
  3102  	// to determine the Accept header
  3103  	localVarHttpHeaderAccepts := []string{
  3104  		"application/json",
  3105  	}
  3106  
  3107  	// set Accept header
  3108  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3109  	if localVarHttpHeaderAccept != "" {
  3110  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3111  	}
  3112  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3113  	if err != nil {
  3114  		return successPayload, nil, err
  3115  	}
  3116  
  3117  	localVarHttpResponse, err := a.client.callAPI(r)
  3118  	if err != nil || localVarHttpResponse == nil {
  3119  		return successPayload, localVarHttpResponse, err
  3120  	}
  3121  	defer localVarHttpResponse.Body.Close()
  3122  	if localVarHttpResponse.StatusCode >= 300 {
  3123  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3124  	}
  3125  
  3126  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3127  		return successPayload, localVarHttpResponse, err
  3128  	}
  3129  
  3130  	return successPayload, localVarHttpResponse, err
  3131  }
  3132  
  3133  /* GroupingObjectsApiService Read EtherTypeNSService
  3134  Returns information about the specified EtherTypeNSService
  3135  * @param ctx context.Context Authentication Context
  3136  @param nsServiceId NSService Id
  3137  @return manager.EtherTypeNsService*/
  3138  func (a *GroupingObjectsApiService) ReadEtherTypeNSService(ctx context.Context, nsServiceId string) (manager.EtherTypeNsService, *http.Response, error) {
  3139  	var (
  3140  		localVarHttpMethod = strings.ToUpper("Get")
  3141  		localVarPostBody   interface{}
  3142  		localVarFileName   string
  3143  		localVarFileBytes  []byte
  3144  		successPayload     manager.EtherTypeNsService
  3145  	)
  3146  
  3147  	// create path and map variables
  3148  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3149  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3150  
  3151  	localVarHeaderParams := make(map[string]string)
  3152  	localVarQueryParams := url.Values{}
  3153  	localVarFormParams := url.Values{}
  3154  
  3155  	// to determine the Content-Type header
  3156  	localVarHttpContentTypes := []string{"application/json"}
  3157  
  3158  	// set Content-Type header
  3159  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3160  	if localVarHttpContentType != "" {
  3161  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3162  	}
  3163  
  3164  	// to determine the Accept header
  3165  	localVarHttpHeaderAccepts := []string{
  3166  		"application/json",
  3167  	}
  3168  
  3169  	// set Accept header
  3170  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3171  	if localVarHttpHeaderAccept != "" {
  3172  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3173  	}
  3174  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3175  	if err != nil {
  3176  		return successPayload, nil, err
  3177  	}
  3178  
  3179  	localVarHttpResponse, err := a.client.callAPI(r)
  3180  	if err != nil || localVarHttpResponse == nil {
  3181  		return successPayload, localVarHttpResponse, err
  3182  	}
  3183  	defer localVarHttpResponse.Body.Close()
  3184  	if localVarHttpResponse.StatusCode >= 300 {
  3185  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3186  	}
  3187  
  3188  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3189  		return successPayload, localVarHttpResponse, err
  3190  	}
  3191  
  3192  	return successPayload, localVarHttpResponse, err
  3193  }
  3194  
  3195  /* GroupingObjectsApiService Read IpProtocolNSService
  3196  Returns information about the specified IpProtocolNSService
  3197  * @param ctx context.Context Authentication Context
  3198  @param nsServiceId NSService Id
  3199  @return manager.IpProtocolNsService*/
  3200  func (a *GroupingObjectsApiService) ReadIpProtocolNSService(ctx context.Context, nsServiceId string) (manager.IpProtocolNsService, *http.Response, error) {
  3201  	var (
  3202  		localVarHttpMethod = strings.ToUpper("Get")
  3203  		localVarPostBody   interface{}
  3204  		localVarFileName   string
  3205  		localVarFileBytes  []byte
  3206  		successPayload     manager.IpProtocolNsService
  3207  	)
  3208  
  3209  	// create path and map variables
  3210  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3211  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3212  
  3213  	localVarHeaderParams := make(map[string]string)
  3214  	localVarQueryParams := url.Values{}
  3215  	localVarFormParams := url.Values{}
  3216  
  3217  	// to determine the Content-Type header
  3218  	localVarHttpContentTypes := []string{"application/json"}
  3219  
  3220  	// set Content-Type header
  3221  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3222  	if localVarHttpContentType != "" {
  3223  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3224  	}
  3225  
  3226  	// to determine the Accept header
  3227  	localVarHttpHeaderAccepts := []string{
  3228  		"application/json",
  3229  	}
  3230  
  3231  	// set Accept header
  3232  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3233  	if localVarHttpHeaderAccept != "" {
  3234  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3235  	}
  3236  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3237  	if err != nil {
  3238  		return successPayload, nil, err
  3239  	}
  3240  
  3241  	localVarHttpResponse, err := a.client.callAPI(r)
  3242  	if err != nil || localVarHttpResponse == nil {
  3243  		return successPayload, localVarHttpResponse, err
  3244  	}
  3245  	defer localVarHttpResponse.Body.Close()
  3246  	if localVarHttpResponse.StatusCode >= 300 {
  3247  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3248  	}
  3249  
  3250  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3251  		return successPayload, localVarHttpResponse, err
  3252  	}
  3253  
  3254  	return successPayload, localVarHttpResponse, err
  3255  }
  3256  
  3257  /* GroupingObjectsApiService Read NSServiceGroup
  3258  Returns information about the specified NSServiceGroup
  3259  * @param ctx context.Context Authentication Context
  3260  @param nsServiceGroupId NSServiceGroup Id
  3261  @return manager.NsServiceGroup*/
  3262  func (a *GroupingObjectsApiService) ReadNSServiceGroup(ctx context.Context, nsServiceGroupId string) (manager.NsServiceGroup, *http.Response, error) {
  3263  	var (
  3264  		localVarHttpMethod = strings.ToUpper("Get")
  3265  		localVarPostBody   interface{}
  3266  		localVarFileName   string
  3267  		localVarFileBytes  []byte
  3268  		successPayload     manager.NsServiceGroup
  3269  	)
  3270  
  3271  	// create path and map variables
  3272  	localVarPath := a.client.cfg.BasePath + "/ns-service-groups/{ns-service-group-id}"
  3273  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-group-id"+"}", fmt.Sprintf("%v", nsServiceGroupId), -1)
  3274  
  3275  	localVarHeaderParams := make(map[string]string)
  3276  	localVarQueryParams := url.Values{}
  3277  	localVarFormParams := url.Values{}
  3278  
  3279  	// to determine the Content-Type header
  3280  	localVarHttpContentTypes := []string{"application/json"}
  3281  
  3282  	// set Content-Type header
  3283  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3284  	if localVarHttpContentType != "" {
  3285  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3286  	}
  3287  
  3288  	// to determine the Accept header
  3289  	localVarHttpHeaderAccepts := []string{
  3290  		"application/json",
  3291  	}
  3292  
  3293  	// set Accept header
  3294  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3295  	if localVarHttpHeaderAccept != "" {
  3296  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3297  	}
  3298  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3299  	if err != nil {
  3300  		return successPayload, nil, err
  3301  	}
  3302  
  3303  	localVarHttpResponse, err := a.client.callAPI(r)
  3304  	if err != nil || localVarHttpResponse == nil {
  3305  		return successPayload, localVarHttpResponse, err
  3306  	}
  3307  	defer localVarHttpResponse.Body.Close()
  3308  	if localVarHttpResponse.StatusCode >= 300 {
  3309  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3310  	}
  3311  
  3312  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3313  		return successPayload, localVarHttpResponse, err
  3314  	}
  3315  
  3316  	return successPayload, localVarHttpResponse, err
  3317  }
  3318  
  3319  /* GroupingObjectsApiService Remove a MAC address from given MACSet
  3320  Remove an individual MAC address from a MACSet
  3321  * @param ctx context.Context Authentication Context
  3322  @param macSetId MACSet Id
  3323  @param macAddress MAC address to be removed
  3324  @return */
  3325  func (a *GroupingObjectsApiService) RemoveMACAddress(ctx context.Context, macSetId string, macAddress string) (*http.Response, error) {
  3326  	var (
  3327  		localVarHttpMethod = strings.ToUpper("Delete")
  3328  		localVarPostBody   interface{}
  3329  		localVarFileName   string
  3330  		localVarFileBytes  []byte
  3331  	)
  3332  
  3333  	// create path and map variables
  3334  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}/members/{mac-address}"
  3335  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -1)
  3336  	localVarPath = strings.Replace(localVarPath, "{"+"mac-address"+"}", fmt.Sprintf("%v", macAddress), -1)
  3337  
  3338  	localVarHeaderParams := make(map[string]string)
  3339  	localVarQueryParams := url.Values{}
  3340  	localVarFormParams := url.Values{}
  3341  
  3342  	// to determine the Content-Type header
  3343  	localVarHttpContentTypes := []string{"application/json"}
  3344  
  3345  	// set Content-Type header
  3346  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3347  	if localVarHttpContentType != "" {
  3348  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3349  	}
  3350  
  3351  	// to determine the Accept header
  3352  	localVarHttpHeaderAccepts := []string{
  3353  		"application/json",
  3354  	}
  3355  
  3356  	// set Accept header
  3357  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3358  	if localVarHttpHeaderAccept != "" {
  3359  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3360  	}
  3361  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3362  	if err != nil {
  3363  		return nil, err
  3364  	}
  3365  
  3366  	localVarHttpResponse, err := a.client.callAPI(r)
  3367  	if err != nil || localVarHttpResponse == nil {
  3368  		return localVarHttpResponse, err
  3369  	}
  3370  	defer localVarHttpResponse.Body.Close()
  3371  	if localVarHttpResponse.StatusCode >= 300 {
  3372  		return localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3373  	}
  3374  
  3375  	return localVarHttpResponse, err
  3376  }
  3377  
  3378  /* GroupingObjectsApiService Update IPSet
  3379  Updates the specified IPSet. Modifiable parameters include description, display_name and ip_addresses.
  3380  * @param ctx context.Context Authentication Context
  3381  @param ipSetId IPSet Id
  3382  @param iPSet
  3383  @return manager.IpSet*/
  3384  func (a *GroupingObjectsApiService) UpdateIPSet(ctx context.Context, ipSetId string, iPSet manager.IpSet) (manager.IpSet, *http.Response, error) {
  3385  	var (
  3386  		localVarHttpMethod = strings.ToUpper("Put")
  3387  		localVarPostBody   interface{}
  3388  		localVarFileName   string
  3389  		localVarFileBytes  []byte
  3390  		successPayload     manager.IpSet
  3391  	)
  3392  
  3393  	// create path and map variables
  3394  	localVarPath := a.client.cfg.BasePath + "/ip-sets/{ip-set-id}"
  3395  	localVarPath = strings.Replace(localVarPath, "{"+"ip-set-id"+"}", fmt.Sprintf("%v", ipSetId), -1)
  3396  
  3397  	localVarHeaderParams := make(map[string]string)
  3398  	localVarQueryParams := url.Values{}
  3399  	localVarFormParams := url.Values{}
  3400  
  3401  	// to determine the Content-Type header
  3402  	localVarHttpContentTypes := []string{"application/json"}
  3403  
  3404  	// set Content-Type header
  3405  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3406  	if localVarHttpContentType != "" {
  3407  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3408  	}
  3409  
  3410  	// to determine the Accept header
  3411  	localVarHttpHeaderAccepts := []string{
  3412  		"application/json",
  3413  	}
  3414  
  3415  	// set Accept header
  3416  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3417  	if localVarHttpHeaderAccept != "" {
  3418  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3419  	}
  3420  	// body params
  3421  	localVarPostBody = &iPSet
  3422  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3423  	if err != nil {
  3424  		return successPayload, nil, err
  3425  	}
  3426  
  3427  	localVarHttpResponse, err := a.client.callAPI(r)
  3428  	if err != nil || localVarHttpResponse == nil {
  3429  		return successPayload, localVarHttpResponse, err
  3430  	}
  3431  	defer localVarHttpResponse.Body.Close()
  3432  	if localVarHttpResponse.StatusCode >= 300 {
  3433  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3434  	}
  3435  
  3436  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3437  		return successPayload, localVarHttpResponse, err
  3438  	}
  3439  
  3440  	return successPayload, localVarHttpResponse, err
  3441  }
  3442  
  3443  /* GroupingObjectsApiService Update MACSet
  3444  Updates the specified MACSet. Modifiable parameters include the description, display_name and mac_addresses.
  3445  * @param ctx context.Context Authentication Context
  3446  @param macSetId MACSet Id
  3447  @param mACSet
  3448  @return manager.MacSet*/
  3449  func (a *GroupingObjectsApiService) UpdateMACSet(ctx context.Context, macSetId string, mACSet manager.MacSet) (manager.MacSet, *http.Response, error) {
  3450  	var (
  3451  		localVarHttpMethod = strings.ToUpper("Put")
  3452  		localVarPostBody   interface{}
  3453  		localVarFileName   string
  3454  		localVarFileBytes  []byte
  3455  		successPayload     manager.MacSet
  3456  	)
  3457  
  3458  	// create path and map variables
  3459  	localVarPath := a.client.cfg.BasePath + "/mac-sets/{mac-set-id}"
  3460  	localVarPath = strings.Replace(localVarPath, "{"+"mac-set-id"+"}", fmt.Sprintf("%v", macSetId), -1)
  3461  
  3462  	localVarHeaderParams := make(map[string]string)
  3463  	localVarQueryParams := url.Values{}
  3464  	localVarFormParams := url.Values{}
  3465  
  3466  	// to determine the Content-Type header
  3467  	localVarHttpContentTypes := []string{"application/json"}
  3468  
  3469  	// set Content-Type header
  3470  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3471  	if localVarHttpContentType != "" {
  3472  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3473  	}
  3474  
  3475  	// to determine the Accept header
  3476  	localVarHttpHeaderAccepts := []string{
  3477  		"application/json",
  3478  	}
  3479  
  3480  	// set Accept header
  3481  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3482  	if localVarHttpHeaderAccept != "" {
  3483  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3484  	}
  3485  	// body params
  3486  	localVarPostBody = &mACSet
  3487  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3488  	if err != nil {
  3489  		return successPayload, nil, err
  3490  	}
  3491  
  3492  	localVarHttpResponse, err := a.client.callAPI(r)
  3493  	if err != nil || localVarHttpResponse == nil {
  3494  		return successPayload, localVarHttpResponse, err
  3495  	}
  3496  	defer localVarHttpResponse.Body.Close()
  3497  	if localVarHttpResponse.StatusCode >= 300 {
  3498  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3499  	}
  3500  
  3501  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3502  		return successPayload, localVarHttpResponse, err
  3503  	}
  3504  
  3505  	return successPayload, localVarHttpResponse, err
  3506  }
  3507  
  3508  /* GroupingObjectsApiService Update NSGroup
  3509  Updates the specified NSGroup. Modifiable parameters include the description, display_name and members.
  3510  * @param ctx context.Context Authentication Context
  3511  @param nsGroupId NSGroup Id
  3512  @param nSGroup
  3513  @return NsGroup*/
  3514  func (a *GroupingObjectsApiService) UpdateNSGroup(ctx context.Context, nsGroupId string, nSGroup manager.NsGroup) (manager.NsGroup, *http.Response, error) {
  3515  	var (
  3516  		localVarHttpMethod = strings.ToUpper("Put")
  3517  		localVarPostBody   interface{}
  3518  		localVarFileName   string
  3519  		localVarFileBytes  []byte
  3520  		successPayload     manager.NsGroup
  3521  	)
  3522  
  3523  	// create path and map variables
  3524  	localVarPath := a.client.cfg.BasePath + "/ns-groups/{ns-group-id}"
  3525  	localVarPath = strings.Replace(localVarPath, "{"+"ns-group-id"+"}", fmt.Sprintf("%v", nsGroupId), -1)
  3526  
  3527  	localVarHeaderParams := make(map[string]string)
  3528  	localVarQueryParams := url.Values{}
  3529  	localVarFormParams := url.Values{}
  3530  
  3531  	// to determine the Content-Type header
  3532  	localVarHttpContentTypes := []string{"application/json"}
  3533  
  3534  	// set Content-Type header
  3535  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3536  	if localVarHttpContentType != "" {
  3537  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3538  	}
  3539  
  3540  	// to determine the Accept header
  3541  	localVarHttpHeaderAccepts := []string{
  3542  		"application/json",
  3543  	}
  3544  
  3545  	// set Accept header
  3546  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3547  	if localVarHttpHeaderAccept != "" {
  3548  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3549  	}
  3550  	// body params
  3551  	localVarPostBody = &nSGroup
  3552  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3553  	if err != nil {
  3554  		return successPayload, nil, err
  3555  	}
  3556  
  3557  	localVarHttpResponse, err := a.client.callAPI(r)
  3558  	if err != nil || localVarHttpResponse == nil {
  3559  		return successPayload, localVarHttpResponse, err
  3560  	}
  3561  	defer localVarHttpResponse.Body.Close()
  3562  	if localVarHttpResponse.StatusCode >= 300 {
  3563  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3564  	}
  3565  
  3566  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3567  		return successPayload, localVarHttpResponse, err
  3568  	}
  3569  
  3570  	return successPayload, localVarHttpResponse, err
  3571  }
  3572  
  3573  /* GroupingObjectsApiService Update NSService
  3574  Updates the specified NSService. Modifiable parameters include the description, display_name and the NSService element. The system defined NSServices can't be modified
  3575  * @param ctx context.Context Authentication Context
  3576  @param nsServiceId NSService Id
  3577  @param nSService
  3578  @return manager.NsService*/
  3579  func (a *GroupingObjectsApiService) UpdateNSService(ctx context.Context, nsServiceId string, nSService manager.NsService) (manager.NsService, *http.Response, error) {
  3580  	var (
  3581  		localVarHttpMethod = strings.ToUpper("Put")
  3582  		localVarPostBody   interface{}
  3583  		localVarFileName   string
  3584  		localVarFileBytes  []byte
  3585  		successPayload     manager.NsService
  3586  	)
  3587  
  3588  	// create path and map variables
  3589  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3590  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3591  
  3592  	localVarHeaderParams := make(map[string]string)
  3593  	localVarQueryParams := url.Values{}
  3594  	localVarFormParams := url.Values{}
  3595  
  3596  	// to determine the Content-Type header
  3597  	localVarHttpContentTypes := []string{"application/json"}
  3598  
  3599  	// set Content-Type header
  3600  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3601  	if localVarHttpContentType != "" {
  3602  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3603  	}
  3604  
  3605  	// to determine the Accept header
  3606  	localVarHttpHeaderAccepts := []string{
  3607  		"application/json",
  3608  	}
  3609  
  3610  	// set Accept header
  3611  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3612  	if localVarHttpHeaderAccept != "" {
  3613  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3614  	}
  3615  	// body params
  3616  	localVarPostBody = &nSService
  3617  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3618  	if err != nil {
  3619  		return successPayload, nil, err
  3620  	}
  3621  
  3622  	localVarHttpResponse, err := a.client.callAPI(r)
  3623  	if err != nil || localVarHttpResponse == nil {
  3624  		return successPayload, localVarHttpResponse, err
  3625  	}
  3626  	defer localVarHttpResponse.Body.Close()
  3627  	if localVarHttpResponse.StatusCode >= 300 {
  3628  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3629  	}
  3630  
  3631  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3632  		return successPayload, localVarHttpResponse, err
  3633  	}
  3634  
  3635  	return successPayload, localVarHttpResponse, err
  3636  }
  3637  
  3638  /* GroupingObjectsApiService Update L4PortSetNSService
  3639  Updates the specified NSService. Modifiable parameters include the description, display_name and the L4PortSetNSService element. The system defined NSServices can't be modified
  3640  * @param ctx context.Context Authentication Context
  3641  @param nsServiceId NSService Id
  3642  @param nSService
  3643  @return manager.L4PortSetNsService*/
  3644  func (a *GroupingObjectsApiService) UpdateL4PortSetNSService(ctx context.Context, nsServiceId string, nSService manager.L4PortSetNsService) (manager.L4PortSetNsService, *http.Response, error) {
  3645  	var (
  3646  		localVarHttpMethod = strings.ToUpper("Put")
  3647  		localVarPostBody   interface{}
  3648  		localVarFileName   string
  3649  		localVarFileBytes  []byte
  3650  		successPayload     manager.L4PortSetNsService
  3651  	)
  3652  
  3653  	// create path and map variables
  3654  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3655  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3656  
  3657  	localVarHeaderParams := make(map[string]string)
  3658  	localVarQueryParams := url.Values{}
  3659  	localVarFormParams := url.Values{}
  3660  
  3661  	// to determine the Content-Type header
  3662  	localVarHttpContentTypes := []string{"application/json"}
  3663  
  3664  	// set Content-Type header
  3665  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3666  	if localVarHttpContentType != "" {
  3667  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3668  	}
  3669  
  3670  	// to determine the Accept header
  3671  	localVarHttpHeaderAccepts := []string{
  3672  		"application/json",
  3673  	}
  3674  
  3675  	// set Accept header
  3676  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3677  	if localVarHttpHeaderAccept != "" {
  3678  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3679  	}
  3680  	// body params
  3681  	localVarPostBody = &nSService
  3682  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3683  	if err != nil {
  3684  		return successPayload, nil, err
  3685  	}
  3686  
  3687  	localVarHttpResponse, err := a.client.callAPI(r)
  3688  	if err != nil || localVarHttpResponse == nil {
  3689  		return successPayload, localVarHttpResponse, err
  3690  	}
  3691  	defer localVarHttpResponse.Body.Close()
  3692  	if localVarHttpResponse.StatusCode >= 300 {
  3693  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3694  	}
  3695  
  3696  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3697  		return successPayload, localVarHttpResponse, err
  3698  	}
  3699  
  3700  	return successPayload, localVarHttpResponse, err
  3701  }
  3702  
  3703  /* GroupingObjectsApiService Update IcmpTypeNSService
  3704  Updates the specified NSService. Modifiable parameters include the description, display_name and the IcmpTypeNSService element. The system defined NSServices can't be modified
  3705  * @param ctx context.Context Authentication Context
  3706  @param nsServiceId NSService Id
  3707  @param nSService
  3708  @return manager.IcmpTypeNsService*/
  3709  func (a *GroupingObjectsApiService) UpdateIcmpTypeNSService(ctx context.Context, nsServiceId string, nSService manager.IcmpTypeNsService) (manager.IcmpTypeNsService, *http.Response, error) {
  3710  	var (
  3711  		localVarHttpMethod = strings.ToUpper("Put")
  3712  		localVarPostBody   interface{}
  3713  		localVarFileName   string
  3714  		localVarFileBytes  []byte
  3715  		successPayload     manager.IcmpTypeNsService
  3716  	)
  3717  
  3718  	// create path and map variables
  3719  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3720  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3721  
  3722  	localVarHeaderParams := make(map[string]string)
  3723  	localVarQueryParams := url.Values{}
  3724  	localVarFormParams := url.Values{}
  3725  
  3726  	// to determine the Content-Type header
  3727  	localVarHttpContentTypes := []string{"application/json"}
  3728  
  3729  	// set Content-Type header
  3730  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3731  	if localVarHttpContentType != "" {
  3732  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3733  	}
  3734  
  3735  	// to determine the Accept header
  3736  	localVarHttpHeaderAccepts := []string{
  3737  		"application/json",
  3738  	}
  3739  
  3740  	// set Accept header
  3741  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3742  	if localVarHttpHeaderAccept != "" {
  3743  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3744  	}
  3745  	// body params
  3746  	localVarPostBody = &nSService
  3747  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3748  	if err != nil {
  3749  		return successPayload, nil, err
  3750  	}
  3751  
  3752  	localVarHttpResponse, err := a.client.callAPI(r)
  3753  	if err != nil || localVarHttpResponse == nil {
  3754  		return successPayload, localVarHttpResponse, err
  3755  	}
  3756  	defer localVarHttpResponse.Body.Close()
  3757  	if localVarHttpResponse.StatusCode >= 300 {
  3758  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3759  	}
  3760  
  3761  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3762  		return successPayload, localVarHttpResponse, err
  3763  	}
  3764  
  3765  	return successPayload, localVarHttpResponse, err
  3766  }
  3767  
  3768  /* GroupingObjectsApiService Update IgmpTypeNSService
  3769  Updates the specified NSService. Modifiable parameters include the description, display_name and the IgmpTypeNSService element. The system defined NSServices can't be modified
  3770  * @param ctx context.Context Authentication Context
  3771  @param nsServiceId NSService Id
  3772  @param nSService
  3773  @return manager.IgmpTypeNsService*/
  3774  func (a *GroupingObjectsApiService) UpdateIgmpTypeNSService(ctx context.Context, nsServiceId string, nSService manager.IgmpTypeNsService) (manager.IgmpTypeNsService, *http.Response, error) {
  3775  	var (
  3776  		localVarHttpMethod = strings.ToUpper("Put")
  3777  		localVarPostBody   interface{}
  3778  		localVarFileName   string
  3779  		localVarFileBytes  []byte
  3780  		successPayload     manager.IgmpTypeNsService
  3781  	)
  3782  
  3783  	// create path and map variables
  3784  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3785  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3786  
  3787  	localVarHeaderParams := make(map[string]string)
  3788  	localVarQueryParams := url.Values{}
  3789  	localVarFormParams := url.Values{}
  3790  
  3791  	// to determine the Content-Type header
  3792  	localVarHttpContentTypes := []string{"application/json"}
  3793  
  3794  	// set Content-Type header
  3795  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3796  	if localVarHttpContentType != "" {
  3797  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3798  	}
  3799  
  3800  	// to determine the Accept header
  3801  	localVarHttpHeaderAccepts := []string{
  3802  		"application/json",
  3803  	}
  3804  
  3805  	// set Accept header
  3806  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3807  	if localVarHttpHeaderAccept != "" {
  3808  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3809  	}
  3810  	// body params
  3811  	localVarPostBody = &nSService
  3812  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3813  	if err != nil {
  3814  		return successPayload, nil, err
  3815  	}
  3816  
  3817  	localVarHttpResponse, err := a.client.callAPI(r)
  3818  	if err != nil || localVarHttpResponse == nil {
  3819  		return successPayload, localVarHttpResponse, err
  3820  	}
  3821  	defer localVarHttpResponse.Body.Close()
  3822  	if localVarHttpResponse.StatusCode >= 300 {
  3823  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3824  	}
  3825  
  3826  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3827  		return successPayload, localVarHttpResponse, err
  3828  	}
  3829  
  3830  	return successPayload, localVarHttpResponse, err
  3831  }
  3832  
  3833  /* GroupingObjectsApiService Update AlgTypeNSService
  3834  Updates the specified NSService. Modifiable parameters include the description, display_name and the AlgTypeNSService element. The system defined NSServices can't be modified
  3835  * @param ctx context.Context Authentication Context
  3836  @param nsServiceId NSService Id
  3837  @param nSService
  3838  @return manager.AlgTypeNsService*/
  3839  func (a *GroupingObjectsApiService) UpdateAlgTypeNSService(ctx context.Context, nsServiceId string, nSService manager.AlgTypeNsService) (manager.AlgTypeNsService, *http.Response, error) {
  3840  	var (
  3841  		localVarHttpMethod = strings.ToUpper("Put")
  3842  		localVarPostBody   interface{}
  3843  		localVarFileName   string
  3844  		localVarFileBytes  []byte
  3845  		successPayload     manager.AlgTypeNsService
  3846  	)
  3847  
  3848  	// create path and map variables
  3849  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3850  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3851  
  3852  	localVarHeaderParams := make(map[string]string)
  3853  	localVarQueryParams := url.Values{}
  3854  	localVarFormParams := url.Values{}
  3855  
  3856  	// to determine the Content-Type header
  3857  	localVarHttpContentTypes := []string{"application/json"}
  3858  
  3859  	// set Content-Type header
  3860  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3861  	if localVarHttpContentType != "" {
  3862  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3863  	}
  3864  
  3865  	// to determine the Accept header
  3866  	localVarHttpHeaderAccepts := []string{
  3867  		"application/json",
  3868  	}
  3869  
  3870  	// set Accept header
  3871  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3872  	if localVarHttpHeaderAccept != "" {
  3873  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3874  	}
  3875  	// body params
  3876  	localVarPostBody = &nSService
  3877  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3878  	if err != nil {
  3879  		return successPayload, nil, err
  3880  	}
  3881  
  3882  	localVarHttpResponse, err := a.client.callAPI(r)
  3883  	if err != nil || localVarHttpResponse == nil {
  3884  		return successPayload, localVarHttpResponse, err
  3885  	}
  3886  	defer localVarHttpResponse.Body.Close()
  3887  	if localVarHttpResponse.StatusCode >= 300 {
  3888  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3889  	}
  3890  
  3891  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3892  		return successPayload, localVarHttpResponse, err
  3893  	}
  3894  
  3895  	return successPayload, localVarHttpResponse, err
  3896  }
  3897  
  3898  /* GroupingObjectsApiService Update EtherTypeNSService
  3899  Updates the specified NSService. Modifiable parameters include the description, display_name and the EtherTypeNSService element. The system defined NSServices can't be modified
  3900  * @param ctx context.Context Authentication Context
  3901  @param nsServiceId NSService Id
  3902  @param nSService
  3903  @return manager.EtherTypeNsService*/
  3904  func (a *GroupingObjectsApiService) UpdateEtherTypeNSService(ctx context.Context, nsServiceId string, nSService manager.EtherTypeNsService) (manager.EtherTypeNsService, *http.Response, error) {
  3905  	var (
  3906  		localVarHttpMethod = strings.ToUpper("Put")
  3907  		localVarPostBody   interface{}
  3908  		localVarFileName   string
  3909  		localVarFileBytes  []byte
  3910  		successPayload     manager.EtherTypeNsService
  3911  	)
  3912  
  3913  	// create path and map variables
  3914  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3915  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3916  
  3917  	localVarHeaderParams := make(map[string]string)
  3918  	localVarQueryParams := url.Values{}
  3919  	localVarFormParams := url.Values{}
  3920  
  3921  	// to determine the Content-Type header
  3922  	localVarHttpContentTypes := []string{"application/json"}
  3923  
  3924  	// set Content-Type header
  3925  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3926  	if localVarHttpContentType != "" {
  3927  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3928  	}
  3929  
  3930  	// to determine the Accept header
  3931  	localVarHttpHeaderAccepts := []string{
  3932  		"application/json",
  3933  	}
  3934  
  3935  	// set Accept header
  3936  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  3937  	if localVarHttpHeaderAccept != "" {
  3938  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  3939  	}
  3940  	// body params
  3941  	localVarPostBody = &nSService
  3942  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  3943  	if err != nil {
  3944  		return successPayload, nil, err
  3945  	}
  3946  
  3947  	localVarHttpResponse, err := a.client.callAPI(r)
  3948  	if err != nil || localVarHttpResponse == nil {
  3949  		return successPayload, localVarHttpResponse, err
  3950  	}
  3951  	defer localVarHttpResponse.Body.Close()
  3952  	if localVarHttpResponse.StatusCode >= 300 {
  3953  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  3954  	}
  3955  
  3956  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  3957  		return successPayload, localVarHttpResponse, err
  3958  	}
  3959  
  3960  	return successPayload, localVarHttpResponse, err
  3961  }
  3962  
  3963  /* GroupingObjectsApiService Update IpProtocolNSService
  3964  Updates the specified NSService. Modifiable parameters include the description, display_name and the IpProtocolNSService element. The system defined NSServices can't be modified
  3965  * @param ctx context.Context Authentication Context
  3966  @param nsServiceId NSService Id
  3967  @param nSService
  3968  @return manager.IpProtocolNsService*/
  3969  func (a *GroupingObjectsApiService) UpdateIpProtocolNSService(ctx context.Context, nsServiceId string, nSService manager.IpProtocolNsService) (manager.IpProtocolNsService, *http.Response, error) {
  3970  	var (
  3971  		localVarHttpMethod = strings.ToUpper("Put")
  3972  		localVarPostBody   interface{}
  3973  		localVarFileName   string
  3974  		localVarFileBytes  []byte
  3975  		successPayload     manager.IpProtocolNsService
  3976  	)
  3977  
  3978  	// create path and map variables
  3979  	localVarPath := a.client.cfg.BasePath + "/ns-services/{ns-service-id}"
  3980  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-id"+"}", fmt.Sprintf("%v", nsServiceId), -1)
  3981  
  3982  	localVarHeaderParams := make(map[string]string)
  3983  	localVarQueryParams := url.Values{}
  3984  	localVarFormParams := url.Values{}
  3985  
  3986  	// to determine the Content-Type header
  3987  	localVarHttpContentTypes := []string{"application/json"}
  3988  
  3989  	// set Content-Type header
  3990  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  3991  	if localVarHttpContentType != "" {
  3992  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  3993  	}
  3994  
  3995  	// to determine the Accept header
  3996  	localVarHttpHeaderAccepts := []string{
  3997  		"application/json",
  3998  	}
  3999  
  4000  	// set Accept header
  4001  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  4002  	if localVarHttpHeaderAccept != "" {
  4003  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  4004  	}
  4005  	// body params
  4006  	localVarPostBody = &nSService
  4007  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  4008  	if err != nil {
  4009  		return successPayload, nil, err
  4010  	}
  4011  
  4012  	localVarHttpResponse, err := a.client.callAPI(r)
  4013  	if err != nil || localVarHttpResponse == nil {
  4014  		return successPayload, localVarHttpResponse, err
  4015  	}
  4016  	defer localVarHttpResponse.Body.Close()
  4017  	if localVarHttpResponse.StatusCode >= 300 {
  4018  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  4019  	}
  4020  
  4021  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  4022  		return successPayload, localVarHttpResponse, err
  4023  	}
  4024  
  4025  	return successPayload, localVarHttpResponse, err
  4026  }
  4027  
  4028  /* GroupingObjectsApiService Update NSServiceGroup
  4029  Updates the specified NSService. Modifiable parameters include the description, display_name and members.
  4030  * @param ctx context.Context Authentication Context
  4031  @param nsServiceGroupId NSServiceGroup Id
  4032  @param nSServiceGroup
  4033  @return manager.NsServiceGroup*/
  4034  func (a *GroupingObjectsApiService) UpdateNSServiceGroup(ctx context.Context, nsServiceGroupId string, nSServiceGroup manager.NsServiceGroup) (manager.NsServiceGroup, *http.Response, error) {
  4035  	var (
  4036  		localVarHttpMethod = strings.ToUpper("Put")
  4037  		localVarPostBody   interface{}
  4038  		localVarFileName   string
  4039  		localVarFileBytes  []byte
  4040  		successPayload     manager.NsServiceGroup
  4041  	)
  4042  
  4043  	// create path and map variables
  4044  	localVarPath := a.client.cfg.BasePath + "/ns-service-groups/{ns-service-group-id}"
  4045  	localVarPath = strings.Replace(localVarPath, "{"+"ns-service-group-id"+"}", fmt.Sprintf("%v", nsServiceGroupId), -1)
  4046  
  4047  	localVarHeaderParams := make(map[string]string)
  4048  	localVarQueryParams := url.Values{}
  4049  	localVarFormParams := url.Values{}
  4050  
  4051  	// to determine the Content-Type header
  4052  	localVarHttpContentTypes := []string{"application/json"}
  4053  
  4054  	// set Content-Type header
  4055  	localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes)
  4056  	if localVarHttpContentType != "" {
  4057  		localVarHeaderParams["Content-Type"] = localVarHttpContentType
  4058  	}
  4059  
  4060  	// to determine the Accept header
  4061  	localVarHttpHeaderAccepts := []string{
  4062  		"application/json",
  4063  	}
  4064  
  4065  	// set Accept header
  4066  	localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts)
  4067  	if localVarHttpHeaderAccept != "" {
  4068  		localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
  4069  	}
  4070  	// body params
  4071  	localVarPostBody = &nSServiceGroup
  4072  	r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes)
  4073  	if err != nil {
  4074  		return successPayload, nil, err
  4075  	}
  4076  
  4077  	localVarHttpResponse, err := a.client.callAPI(r)
  4078  	if err != nil || localVarHttpResponse == nil {
  4079  		return successPayload, localVarHttpResponse, err
  4080  	}
  4081  	defer localVarHttpResponse.Body.Close()
  4082  	if localVarHttpResponse.StatusCode >= 300 {
  4083  		return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status)
  4084  	}
  4085  
  4086  	if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil {
  4087  		return successPayload, localVarHttpResponse, err
  4088  	}
  4089  
  4090  	return successPayload, localVarHttpResponse, err
  4091  }