1package network 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/tracing" 14 "net/http" 15) 16 17// IPGroupsClient is the network Client 18type IPGroupsClient struct { 19 BaseClient 20} 21 22// NewIPGroupsClient creates an instance of the IPGroupsClient client. 23func NewIPGroupsClient(subscriptionID string) IPGroupsClient { 24 return NewIPGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID) 25} 26 27// NewIPGroupsClientWithBaseURI creates an instance of the IPGroupsClient client using a custom endpoint. Use this 28// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 29func NewIPGroupsClientWithBaseURI(baseURI string, subscriptionID string) IPGroupsClient { 30 return IPGroupsClient{NewWithBaseURI(baseURI, subscriptionID)} 31} 32 33// CreateOrUpdate creates or updates an ipGroups in a specified resource group. 34// Parameters: 35// resourceGroupName - the name of the resource group. 36// IPGroupsName - the name of the ipGroups. 37// parameters - parameters supplied to the create or update IpGroups operation. 38func (client IPGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters IPGroup) (result IPGroupsCreateOrUpdateFuture, err error) { 39 if tracing.IsEnabled() { 40 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.CreateOrUpdate") 41 defer func() { 42 sc := -1 43 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 44 sc = result.FutureAPI.Response().StatusCode 45 } 46 tracing.EndSpan(ctx, sc, err) 47 }() 48 } 49 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, IPGroupsName, parameters) 50 if err != nil { 51 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "CreateOrUpdate", nil, "Failure preparing request") 52 return 53 } 54 55 result, err = client.CreateOrUpdateSender(req) 56 if err != nil { 57 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "CreateOrUpdate", nil, "Failure sending request") 58 return 59 } 60 61 return 62} 63 64// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 65func (client IPGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters IPGroup) (*http.Request, error) { 66 pathParameters := map[string]interface{}{ 67 "ipGroupsName": autorest.Encode("path", IPGroupsName), 68 "resourceGroupName": autorest.Encode("path", resourceGroupName), 69 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 70 } 71 72 const APIVersion = "2020-06-01" 73 queryParameters := map[string]interface{}{ 74 "api-version": APIVersion, 75 } 76 77 parameters.Etag = nil 78 preparer := autorest.CreatePreparer( 79 autorest.AsContentType("application/json; charset=utf-8"), 80 autorest.AsPut(), 81 autorest.WithBaseURL(client.BaseURI), 82 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 83 autorest.WithJSON(parameters), 84 autorest.WithQueryParameters(queryParameters)) 85 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 86} 87 88// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 89// http.Response Body if it receives an error. 90func (client IPGroupsClient) CreateOrUpdateSender(req *http.Request) (future IPGroupsCreateOrUpdateFuture, err error) { 91 var resp *http.Response 92 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 93 if err != nil { 94 return 95 } 96 var azf azure.Future 97 azf, err = azure.NewFutureFromResponse(resp) 98 future.FutureAPI = &azf 99 future.Result = future.result 100 return 101} 102 103// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 104// closes the http.Response Body. 105func (client IPGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result IPGroup, err error) { 106 err = autorest.Respond( 107 resp, 108 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 109 autorest.ByUnmarshallingJSON(&result), 110 autorest.ByClosing()) 111 result.Response = autorest.Response{Response: resp} 112 return 113} 114 115// Delete deletes the specified ipGroups. 116// Parameters: 117// resourceGroupName - the name of the resource group. 118// IPGroupsName - the name of the ipGroups. 119func (client IPGroupsClient) Delete(ctx context.Context, resourceGroupName string, IPGroupsName string) (result IPGroupsDeleteFuture, err error) { 120 if tracing.IsEnabled() { 121 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.Delete") 122 defer func() { 123 sc := -1 124 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 125 sc = result.FutureAPI.Response().StatusCode 126 } 127 tracing.EndSpan(ctx, sc, err) 128 }() 129 } 130 req, err := client.DeletePreparer(ctx, resourceGroupName, IPGroupsName) 131 if err != nil { 132 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Delete", nil, "Failure preparing request") 133 return 134 } 135 136 result, err = client.DeleteSender(req) 137 if err != nil { 138 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Delete", nil, "Failure sending request") 139 return 140 } 141 142 return 143} 144 145// DeletePreparer prepares the Delete request. 146func (client IPGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, IPGroupsName string) (*http.Request, error) { 147 pathParameters := map[string]interface{}{ 148 "ipGroupsName": autorest.Encode("path", IPGroupsName), 149 "resourceGroupName": autorest.Encode("path", resourceGroupName), 150 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 151 } 152 153 const APIVersion = "2020-06-01" 154 queryParameters := map[string]interface{}{ 155 "api-version": APIVersion, 156 } 157 158 preparer := autorest.CreatePreparer( 159 autorest.AsDelete(), 160 autorest.WithBaseURL(client.BaseURI), 161 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 162 autorest.WithQueryParameters(queryParameters)) 163 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 164} 165 166// DeleteSender sends the Delete request. The method will close the 167// http.Response Body if it receives an error. 168func (client IPGroupsClient) DeleteSender(req *http.Request) (future IPGroupsDeleteFuture, err error) { 169 var resp *http.Response 170 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 171 if err != nil { 172 return 173 } 174 var azf azure.Future 175 azf, err = azure.NewFutureFromResponse(resp) 176 future.FutureAPI = &azf 177 future.Result = future.result 178 return 179} 180 181// DeleteResponder handles the response to the Delete request. The method always 182// closes the http.Response Body. 183func (client IPGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 184 err = autorest.Respond( 185 resp, 186 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 187 autorest.ByClosing()) 188 result.Response = resp 189 return 190} 191 192// Get gets the specified ipGroups. 193// Parameters: 194// resourceGroupName - the name of the resource group. 195// IPGroupsName - the name of the ipGroups. 196// expand - expands resourceIds (of Firewalls/Network Security Groups etc.) back referenced by the IpGroups 197// resource. 198func (client IPGroupsClient) Get(ctx context.Context, resourceGroupName string, IPGroupsName string, expand string) (result IPGroup, err error) { 199 if tracing.IsEnabled() { 200 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.Get") 201 defer func() { 202 sc := -1 203 if result.Response.Response != nil { 204 sc = result.Response.Response.StatusCode 205 } 206 tracing.EndSpan(ctx, sc, err) 207 }() 208 } 209 req, err := client.GetPreparer(ctx, resourceGroupName, IPGroupsName, expand) 210 if err != nil { 211 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", nil, "Failure preparing request") 212 return 213 } 214 215 resp, err := client.GetSender(req) 216 if err != nil { 217 result.Response = autorest.Response{Response: resp} 218 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", resp, "Failure sending request") 219 return 220 } 221 222 result, err = client.GetResponder(resp) 223 if err != nil { 224 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", resp, "Failure responding to request") 225 return 226 } 227 228 return 229} 230 231// GetPreparer prepares the Get request. 232func (client IPGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, expand string) (*http.Request, error) { 233 pathParameters := map[string]interface{}{ 234 "ipGroupsName": autorest.Encode("path", IPGroupsName), 235 "resourceGroupName": autorest.Encode("path", resourceGroupName), 236 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 237 } 238 239 const APIVersion = "2020-06-01" 240 queryParameters := map[string]interface{}{ 241 "api-version": APIVersion, 242 } 243 if len(expand) > 0 { 244 queryParameters["$expand"] = autorest.Encode("query", expand) 245 } 246 247 preparer := autorest.CreatePreparer( 248 autorest.AsGet(), 249 autorest.WithBaseURL(client.BaseURI), 250 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 251 autorest.WithQueryParameters(queryParameters)) 252 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 253} 254 255// GetSender sends the Get request. The method will close the 256// http.Response Body if it receives an error. 257func (client IPGroupsClient) GetSender(req *http.Request) (*http.Response, error) { 258 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 259} 260 261// GetResponder handles the response to the Get request. The method always 262// closes the http.Response Body. 263func (client IPGroupsClient) GetResponder(resp *http.Response) (result IPGroup, err error) { 264 err = autorest.Respond( 265 resp, 266 azure.WithErrorUnlessStatusCode(http.StatusOK), 267 autorest.ByUnmarshallingJSON(&result), 268 autorest.ByClosing()) 269 result.Response = autorest.Response{Response: resp} 270 return 271} 272 273// List gets all IpGroups in a subscription. 274func (client IPGroupsClient) List(ctx context.Context) (result IPGroupListResultPage, err error) { 275 if tracing.IsEnabled() { 276 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.List") 277 defer func() { 278 sc := -1 279 if result.iglr.Response.Response != nil { 280 sc = result.iglr.Response.Response.StatusCode 281 } 282 tracing.EndSpan(ctx, sc, err) 283 }() 284 } 285 result.fn = client.listNextResults 286 req, err := client.ListPreparer(ctx) 287 if err != nil { 288 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", nil, "Failure preparing request") 289 return 290 } 291 292 resp, err := client.ListSender(req) 293 if err != nil { 294 result.iglr.Response = autorest.Response{Response: resp} 295 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", resp, "Failure sending request") 296 return 297 } 298 299 result.iglr, err = client.ListResponder(resp) 300 if err != nil { 301 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", resp, "Failure responding to request") 302 return 303 } 304 if result.iglr.hasNextLink() && result.iglr.IsEmpty() { 305 err = result.NextWithContext(ctx) 306 return 307 } 308 309 return 310} 311 312// ListPreparer prepares the List request. 313func (client IPGroupsClient) ListPreparer(ctx context.Context) (*http.Request, error) { 314 pathParameters := map[string]interface{}{ 315 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 316 } 317 318 const APIVersion = "2020-06-01" 319 queryParameters := map[string]interface{}{ 320 "api-version": APIVersion, 321 } 322 323 preparer := autorest.CreatePreparer( 324 autorest.AsGet(), 325 autorest.WithBaseURL(client.BaseURI), 326 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/ipGroups", pathParameters), 327 autorest.WithQueryParameters(queryParameters)) 328 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 329} 330 331// ListSender sends the List request. The method will close the 332// http.Response Body if it receives an error. 333func (client IPGroupsClient) ListSender(req *http.Request) (*http.Response, error) { 334 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 335} 336 337// ListResponder handles the response to the List request. The method always 338// closes the http.Response Body. 339func (client IPGroupsClient) ListResponder(resp *http.Response) (result IPGroupListResult, err error) { 340 err = autorest.Respond( 341 resp, 342 azure.WithErrorUnlessStatusCode(http.StatusOK), 343 autorest.ByUnmarshallingJSON(&result), 344 autorest.ByClosing()) 345 result.Response = autorest.Response{Response: resp} 346 return 347} 348 349// listNextResults retrieves the next set of results, if any. 350func (client IPGroupsClient) listNextResults(ctx context.Context, lastResults IPGroupListResult) (result IPGroupListResult, err error) { 351 req, err := lastResults.iPGroupListResultPreparer(ctx) 352 if err != nil { 353 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", nil, "Failure preparing next results request") 354 } 355 if req == nil { 356 return 357 } 358 resp, err := client.ListSender(req) 359 if err != nil { 360 result.Response = autorest.Response{Response: resp} 361 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", resp, "Failure sending next results request") 362 } 363 result, err = client.ListResponder(resp) 364 if err != nil { 365 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", resp, "Failure responding to next results request") 366 } 367 return 368} 369 370// ListComplete enumerates all values, automatically crossing page boundaries as required. 371func (client IPGroupsClient) ListComplete(ctx context.Context) (result IPGroupListResultIterator, err error) { 372 if tracing.IsEnabled() { 373 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.List") 374 defer func() { 375 sc := -1 376 if result.Response().Response.Response != nil { 377 sc = result.page.Response().Response.Response.StatusCode 378 } 379 tracing.EndSpan(ctx, sc, err) 380 }() 381 } 382 result.page, err = client.List(ctx) 383 return 384} 385 386// ListByResourceGroup gets all IpGroups in a resource group. 387// Parameters: 388// resourceGroupName - the name of the resource group. 389func (client IPGroupsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IPGroupListResultPage, err error) { 390 if tracing.IsEnabled() { 391 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.ListByResourceGroup") 392 defer func() { 393 sc := -1 394 if result.iglr.Response.Response != nil { 395 sc = result.iglr.Response.Response.StatusCode 396 } 397 tracing.EndSpan(ctx, sc, err) 398 }() 399 } 400 result.fn = client.listByResourceGroupNextResults 401 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 402 if err != nil { 403 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", nil, "Failure preparing request") 404 return 405 } 406 407 resp, err := client.ListByResourceGroupSender(req) 408 if err != nil { 409 result.iglr.Response = autorest.Response{Response: resp} 410 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", resp, "Failure sending request") 411 return 412 } 413 414 result.iglr, err = client.ListByResourceGroupResponder(resp) 415 if err != nil { 416 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", resp, "Failure responding to request") 417 return 418 } 419 if result.iglr.hasNextLink() && result.iglr.IsEmpty() { 420 err = result.NextWithContext(ctx) 421 return 422 } 423 424 return 425} 426 427// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 428func (client IPGroupsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 429 pathParameters := map[string]interface{}{ 430 "resourceGroupName": autorest.Encode("path", resourceGroupName), 431 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 432 } 433 434 const APIVersion = "2020-06-01" 435 queryParameters := map[string]interface{}{ 436 "api-version": APIVersion, 437 } 438 439 preparer := autorest.CreatePreparer( 440 autorest.AsGet(), 441 autorest.WithBaseURL(client.BaseURI), 442 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups", pathParameters), 443 autorest.WithQueryParameters(queryParameters)) 444 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 445} 446 447// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 448// http.Response Body if it receives an error. 449func (client IPGroupsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 450 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 451} 452 453// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 454// closes the http.Response Body. 455func (client IPGroupsClient) ListByResourceGroupResponder(resp *http.Response) (result IPGroupListResult, err error) { 456 err = autorest.Respond( 457 resp, 458 azure.WithErrorUnlessStatusCode(http.StatusOK), 459 autorest.ByUnmarshallingJSON(&result), 460 autorest.ByClosing()) 461 result.Response = autorest.Response{Response: resp} 462 return 463} 464 465// listByResourceGroupNextResults retrieves the next set of results, if any. 466func (client IPGroupsClient) listByResourceGroupNextResults(ctx context.Context, lastResults IPGroupListResult) (result IPGroupListResult, err error) { 467 req, err := lastResults.iPGroupListResultPreparer(ctx) 468 if err != nil { 469 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 470 } 471 if req == nil { 472 return 473 } 474 resp, err := client.ListByResourceGroupSender(req) 475 if err != nil { 476 result.Response = autorest.Response{Response: resp} 477 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 478 } 479 result, err = client.ListByResourceGroupResponder(resp) 480 if err != nil { 481 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 482 } 483 return 484} 485 486// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 487func (client IPGroupsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IPGroupListResultIterator, err error) { 488 if tracing.IsEnabled() { 489 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.ListByResourceGroup") 490 defer func() { 491 sc := -1 492 if result.Response().Response.Response != nil { 493 sc = result.page.Response().Response.Response.StatusCode 494 } 495 tracing.EndSpan(ctx, sc, err) 496 }() 497 } 498 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 499 return 500} 501 502// UpdateGroups updates tags of an IpGroups resource. 503// Parameters: 504// resourceGroupName - the name of the resource group. 505// IPGroupsName - the name of the ipGroups. 506// parameters - parameters supplied to the update ipGroups operation. 507func (client IPGroupsClient) UpdateGroups(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters TagsObject) (result IPGroup, err error) { 508 if tracing.IsEnabled() { 509 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.UpdateGroups") 510 defer func() { 511 sc := -1 512 if result.Response.Response != nil { 513 sc = result.Response.Response.StatusCode 514 } 515 tracing.EndSpan(ctx, sc, err) 516 }() 517 } 518 req, err := client.UpdateGroupsPreparer(ctx, resourceGroupName, IPGroupsName, parameters) 519 if err != nil { 520 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", nil, "Failure preparing request") 521 return 522 } 523 524 resp, err := client.UpdateGroupsSender(req) 525 if err != nil { 526 result.Response = autorest.Response{Response: resp} 527 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", resp, "Failure sending request") 528 return 529 } 530 531 result, err = client.UpdateGroupsResponder(resp) 532 if err != nil { 533 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", resp, "Failure responding to request") 534 return 535 } 536 537 return 538} 539 540// UpdateGroupsPreparer prepares the UpdateGroups request. 541func (client IPGroupsClient) UpdateGroupsPreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters TagsObject) (*http.Request, error) { 542 pathParameters := map[string]interface{}{ 543 "ipGroupsName": autorest.Encode("path", IPGroupsName), 544 "resourceGroupName": autorest.Encode("path", resourceGroupName), 545 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 546 } 547 548 const APIVersion = "2020-06-01" 549 queryParameters := map[string]interface{}{ 550 "api-version": APIVersion, 551 } 552 553 preparer := autorest.CreatePreparer( 554 autorest.AsContentType("application/json; charset=utf-8"), 555 autorest.AsPatch(), 556 autorest.WithBaseURL(client.BaseURI), 557 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 558 autorest.WithJSON(parameters), 559 autorest.WithQueryParameters(queryParameters)) 560 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 561} 562 563// UpdateGroupsSender sends the UpdateGroups request. The method will close the 564// http.Response Body if it receives an error. 565func (client IPGroupsClient) UpdateGroupsSender(req *http.Request) (*http.Response, error) { 566 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 567} 568 569// UpdateGroupsResponder handles the response to the UpdateGroups request. The method always 570// closes the http.Response Body. 571func (client IPGroupsClient) UpdateGroupsResponder(resp *http.Response) (result IPGroup, err error) { 572 err = autorest.Respond( 573 resp, 574 azure.WithErrorUnlessStatusCode(http.StatusOK), 575 autorest.ByUnmarshallingJSON(&result), 576 autorest.ByClosing()) 577 result.Response = autorest.Response{Response: resp} 578 return 579} 580