1// +build go1.13
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// Code generated by Microsoft (R) AutoRest Code Generator.
6// Changes may cause incorrect behavior and will be lost if the code is regenerated.
7
8package armnetwork
9
10import (
11	"context"
12	"errors"
13	"fmt"
14	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
15	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
16	"net/http"
17	"net/url"
18	"strings"
19	"time"
20)
21
22// SubnetsClient contains the methods for the Subnets group.
23// Don't use this type directly, use NewSubnetsClient() instead.
24type SubnetsClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewSubnetsClient creates a new instance of SubnetsClient with the specified values.
30func NewSubnetsClient(con *armcore.Connection, subscriptionID string) *SubnetsClient {
31	return &SubnetsClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreateOrUpdate - Creates or updates a subnet in the specified virtual network.
35// If the operation fails it returns the *CloudError error type.
36func (client *SubnetsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters Subnet, options *SubnetsBeginCreateOrUpdateOptions) (SubnetPollerResponse, error) {
37	resp, err := client.createOrUpdate(ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters, options)
38	if err != nil {
39		return SubnetPollerResponse{}, err
40	}
41	result := SubnetPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("SubnetsClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
45	if err != nil {
46		return SubnetPollerResponse{}, err
47	}
48	poller := &subnetPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (SubnetResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreateOrUpdate creates a new SubnetPoller from the specified resume token.
59// token - The value must come from a previous call to SubnetPoller.ResumeToken().
60func (client *SubnetsClient) ResumeCreateOrUpdate(ctx context.Context, token string) (SubnetPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("SubnetsClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
62	if err != nil {
63		return SubnetPollerResponse{}, err
64	}
65	poller := &subnetPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return SubnetPollerResponse{}, err
71	}
72	result := SubnetPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (SubnetResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// CreateOrUpdate - Creates or updates a subnet in the specified virtual network.
83// If the operation fails it returns the *CloudError error type.
84func (client *SubnetsClient) createOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters Subnet, options *SubnetsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
85	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters, options)
86	if err != nil {
87		return nil, err
88	}
89	resp, err := client.con.Pipeline().Do(req)
90	if err != nil {
91		return nil, err
92	}
93	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
94		return nil, client.createOrUpdateHandleError(resp)
95	}
96	return resp, nil
97}
98
99// createOrUpdateCreateRequest creates the CreateOrUpdate request.
100func (client *SubnetsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters Subnet, options *SubnetsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"
102	if resourceGroupName == "" {
103		return nil, errors.New("parameter resourceGroupName cannot be empty")
104	}
105	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
106	if virtualNetworkName == "" {
107		return nil, errors.New("parameter virtualNetworkName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
110	if subnetName == "" {
111		return nil, errors.New("parameter subnetName cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{subnetName}", url.PathEscape(subnetName))
114	if client.subscriptionID == "" {
115		return nil, errors.New("parameter client.subscriptionID cannot be empty")
116	}
117	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
118	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
119	if err != nil {
120		return nil, err
121	}
122	req.Telemetry(telemetryInfo)
123	reqQP := req.URL.Query()
124	reqQP.Set("api-version", "2021-02-01")
125	req.URL.RawQuery = reqQP.Encode()
126	req.Header.Set("Accept", "application/json")
127	return req, req.MarshalAsJSON(subnetParameters)
128}
129
130// createOrUpdateHandleError handles the CreateOrUpdate error response.
131func (client *SubnetsClient) createOrUpdateHandleError(resp *azcore.Response) error {
132	body, err := resp.Payload()
133	if err != nil {
134		return azcore.NewResponseError(err, resp.Response)
135	}
136	errType := CloudError{raw: string(body)}
137	if err := resp.UnmarshalAsJSON(&errType); err != nil {
138		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
139	}
140	return azcore.NewResponseError(&errType, resp.Response)
141}
142
143// BeginDelete - Deletes the specified subnet.
144// If the operation fails it returns the *CloudError error type.
145func (client *SubnetsClient) BeginDelete(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, options *SubnetsBeginDeleteOptions) (HTTPPollerResponse, error) {
146	resp, err := client.deleteOperation(ctx, resourceGroupName, virtualNetworkName, subnetName, options)
147	if err != nil {
148		return HTTPPollerResponse{}, err
149	}
150	result := HTTPPollerResponse{
151		RawResponse: resp.Response,
152	}
153	pt, err := armcore.NewLROPoller("SubnetsClient.Delete", "location", resp, client.con.Pipeline(), client.deleteHandleError)
154	if err != nil {
155		return HTTPPollerResponse{}, err
156	}
157	poller := &httpPoller{
158		pt: pt,
159	}
160	result.Poller = poller
161	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
162		return poller.pollUntilDone(ctx, frequency)
163	}
164	return result, nil
165}
166
167// ResumeDelete creates a new HTTPPoller from the specified resume token.
168// token - The value must come from a previous call to HTTPPoller.ResumeToken().
169func (client *SubnetsClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
170	pt, err := armcore.NewLROPollerFromResumeToken("SubnetsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
171	if err != nil {
172		return HTTPPollerResponse{}, err
173	}
174	poller := &httpPoller{
175		pt: pt,
176	}
177	resp, err := poller.Poll(ctx)
178	if err != nil {
179		return HTTPPollerResponse{}, err
180	}
181	result := HTTPPollerResponse{
182		RawResponse: resp,
183	}
184	result.Poller = poller
185	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
186		return poller.pollUntilDone(ctx, frequency)
187	}
188	return result, nil
189}
190
191// Delete - Deletes the specified subnet.
192// If the operation fails it returns the *CloudError error type.
193func (client *SubnetsClient) deleteOperation(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, options *SubnetsBeginDeleteOptions) (*azcore.Response, error) {
194	req, err := client.deleteCreateRequest(ctx, resourceGroupName, virtualNetworkName, subnetName, options)
195	if err != nil {
196		return nil, err
197	}
198	resp, err := client.con.Pipeline().Do(req)
199	if err != nil {
200		return nil, err
201	}
202	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
203		return nil, client.deleteHandleError(resp)
204	}
205	return resp, nil
206}
207
208// deleteCreateRequest creates the Delete request.
209func (client *SubnetsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, options *SubnetsBeginDeleteOptions) (*azcore.Request, error) {
210	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"
211	if resourceGroupName == "" {
212		return nil, errors.New("parameter resourceGroupName cannot be empty")
213	}
214	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
215	if virtualNetworkName == "" {
216		return nil, errors.New("parameter virtualNetworkName cannot be empty")
217	}
218	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
219	if subnetName == "" {
220		return nil, errors.New("parameter subnetName cannot be empty")
221	}
222	urlPath = strings.ReplaceAll(urlPath, "{subnetName}", url.PathEscape(subnetName))
223	if client.subscriptionID == "" {
224		return nil, errors.New("parameter client.subscriptionID cannot be empty")
225	}
226	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
227	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
228	if err != nil {
229		return nil, err
230	}
231	req.Telemetry(telemetryInfo)
232	reqQP := req.URL.Query()
233	reqQP.Set("api-version", "2021-02-01")
234	req.URL.RawQuery = reqQP.Encode()
235	req.Header.Set("Accept", "application/json")
236	return req, nil
237}
238
239// deleteHandleError handles the Delete error response.
240func (client *SubnetsClient) deleteHandleError(resp *azcore.Response) error {
241	body, err := resp.Payload()
242	if err != nil {
243		return azcore.NewResponseError(err, resp.Response)
244	}
245	errType := CloudError{raw: string(body)}
246	if err := resp.UnmarshalAsJSON(&errType); err != nil {
247		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
248	}
249	return azcore.NewResponseError(&errType, resp.Response)
250}
251
252// Get - Gets the specified subnet by virtual network and resource group.
253// If the operation fails it returns the *CloudError error type.
254func (client *SubnetsClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, options *SubnetsGetOptions) (SubnetResponse, error) {
255	req, err := client.getCreateRequest(ctx, resourceGroupName, virtualNetworkName, subnetName, options)
256	if err != nil {
257		return SubnetResponse{}, err
258	}
259	resp, err := client.con.Pipeline().Do(req)
260	if err != nil {
261		return SubnetResponse{}, err
262	}
263	if !resp.HasStatusCode(http.StatusOK) {
264		return SubnetResponse{}, client.getHandleError(resp)
265	}
266	return client.getHandleResponse(resp)
267}
268
269// getCreateRequest creates the Get request.
270func (client *SubnetsClient) getCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, options *SubnetsGetOptions) (*azcore.Request, error) {
271	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"
272	if resourceGroupName == "" {
273		return nil, errors.New("parameter resourceGroupName cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
276	if virtualNetworkName == "" {
277		return nil, errors.New("parameter virtualNetworkName cannot be empty")
278	}
279	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
280	if subnetName == "" {
281		return nil, errors.New("parameter subnetName cannot be empty")
282	}
283	urlPath = strings.ReplaceAll(urlPath, "{subnetName}", url.PathEscape(subnetName))
284	if client.subscriptionID == "" {
285		return nil, errors.New("parameter client.subscriptionID cannot be empty")
286	}
287	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
288	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
289	if err != nil {
290		return nil, err
291	}
292	req.Telemetry(telemetryInfo)
293	reqQP := req.URL.Query()
294	reqQP.Set("api-version", "2021-02-01")
295	if options != nil && options.Expand != nil {
296		reqQP.Set("$expand", *options.Expand)
297	}
298	req.URL.RawQuery = reqQP.Encode()
299	req.Header.Set("Accept", "application/json")
300	return req, nil
301}
302
303// getHandleResponse handles the Get response.
304func (client *SubnetsClient) getHandleResponse(resp *azcore.Response) (SubnetResponse, error) {
305	var val *Subnet
306	if err := resp.UnmarshalAsJSON(&val); err != nil {
307		return SubnetResponse{}, err
308	}
309	return SubnetResponse{RawResponse: resp.Response, Subnet: val}, nil
310}
311
312// getHandleError handles the Get error response.
313func (client *SubnetsClient) getHandleError(resp *azcore.Response) error {
314	body, err := resp.Payload()
315	if err != nil {
316		return azcore.NewResponseError(err, resp.Response)
317	}
318	errType := CloudError{raw: string(body)}
319	if err := resp.UnmarshalAsJSON(&errType); err != nil {
320		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
321	}
322	return azcore.NewResponseError(&errType, resp.Response)
323}
324
325// List - Gets all subnets in a virtual network.
326// If the operation fails it returns the *CloudError error type.
327func (client *SubnetsClient) List(resourceGroupName string, virtualNetworkName string, options *SubnetsListOptions) SubnetListResultPager {
328	return &subnetListResultPager{
329		pipeline: client.con.Pipeline(),
330		requester: func(ctx context.Context) (*azcore.Request, error) {
331			return client.listCreateRequest(ctx, resourceGroupName, virtualNetworkName, options)
332		},
333		responder: client.listHandleResponse,
334		errorer:   client.listHandleError,
335		advancer: func(ctx context.Context, resp SubnetListResultResponse) (*azcore.Request, error) {
336			return azcore.NewRequest(ctx, http.MethodGet, *resp.SubnetListResult.NextLink)
337		},
338		statusCodes: []int{http.StatusOK},
339	}
340}
341
342// listCreateRequest creates the List request.
343func (client *SubnetsClient) listCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *SubnetsListOptions) (*azcore.Request, error) {
344	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets"
345	if resourceGroupName == "" {
346		return nil, errors.New("parameter resourceGroupName cannot be empty")
347	}
348	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
349	if virtualNetworkName == "" {
350		return nil, errors.New("parameter virtualNetworkName cannot be empty")
351	}
352	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
353	if client.subscriptionID == "" {
354		return nil, errors.New("parameter client.subscriptionID cannot be empty")
355	}
356	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
357	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
358	if err != nil {
359		return nil, err
360	}
361	req.Telemetry(telemetryInfo)
362	reqQP := req.URL.Query()
363	reqQP.Set("api-version", "2021-02-01")
364	req.URL.RawQuery = reqQP.Encode()
365	req.Header.Set("Accept", "application/json")
366	return req, nil
367}
368
369// listHandleResponse handles the List response.
370func (client *SubnetsClient) listHandleResponse(resp *azcore.Response) (SubnetListResultResponse, error) {
371	var val *SubnetListResult
372	if err := resp.UnmarshalAsJSON(&val); err != nil {
373		return SubnetListResultResponse{}, err
374	}
375	return SubnetListResultResponse{RawResponse: resp.Response, SubnetListResult: val}, nil
376}
377
378// listHandleError handles the List error response.
379func (client *SubnetsClient) listHandleError(resp *azcore.Response) error {
380	body, err := resp.Payload()
381	if err != nil {
382		return azcore.NewResponseError(err, resp.Response)
383	}
384	errType := CloudError{raw: string(body)}
385	if err := resp.UnmarshalAsJSON(&errType); err != nil {
386		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
387	}
388	return azcore.NewResponseError(&errType, resp.Response)
389}
390
391// BeginPrepareNetworkPolicies - Prepares a subnet by applying network intent policies.
392// If the operation fails it returns the *CloudError error type.
393func (client *SubnetsClient) BeginPrepareNetworkPolicies(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, prepareNetworkPoliciesRequestParameters PrepareNetworkPoliciesRequest, options *SubnetsBeginPrepareNetworkPoliciesOptions) (HTTPPollerResponse, error) {
394	resp, err := client.prepareNetworkPolicies(ctx, resourceGroupName, virtualNetworkName, subnetName, prepareNetworkPoliciesRequestParameters, options)
395	if err != nil {
396		return HTTPPollerResponse{}, err
397	}
398	result := HTTPPollerResponse{
399		RawResponse: resp.Response,
400	}
401	pt, err := armcore.NewLROPoller("SubnetsClient.PrepareNetworkPolicies", "location", resp, client.con.Pipeline(), client.prepareNetworkPoliciesHandleError)
402	if err != nil {
403		return HTTPPollerResponse{}, err
404	}
405	poller := &httpPoller{
406		pt: pt,
407	}
408	result.Poller = poller
409	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
410		return poller.pollUntilDone(ctx, frequency)
411	}
412	return result, nil
413}
414
415// ResumePrepareNetworkPolicies creates a new HTTPPoller from the specified resume token.
416// token - The value must come from a previous call to HTTPPoller.ResumeToken().
417func (client *SubnetsClient) ResumePrepareNetworkPolicies(ctx context.Context, token string) (HTTPPollerResponse, error) {
418	pt, err := armcore.NewLROPollerFromResumeToken("SubnetsClient.PrepareNetworkPolicies", token, client.con.Pipeline(), client.prepareNetworkPoliciesHandleError)
419	if err != nil {
420		return HTTPPollerResponse{}, err
421	}
422	poller := &httpPoller{
423		pt: pt,
424	}
425	resp, err := poller.Poll(ctx)
426	if err != nil {
427		return HTTPPollerResponse{}, err
428	}
429	result := HTTPPollerResponse{
430		RawResponse: resp,
431	}
432	result.Poller = poller
433	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
434		return poller.pollUntilDone(ctx, frequency)
435	}
436	return result, nil
437}
438
439// PrepareNetworkPolicies - Prepares a subnet by applying network intent policies.
440// If the operation fails it returns the *CloudError error type.
441func (client *SubnetsClient) prepareNetworkPolicies(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, prepareNetworkPoliciesRequestParameters PrepareNetworkPoliciesRequest, options *SubnetsBeginPrepareNetworkPoliciesOptions) (*azcore.Response, error) {
442	req, err := client.prepareNetworkPoliciesCreateRequest(ctx, resourceGroupName, virtualNetworkName, subnetName, prepareNetworkPoliciesRequestParameters, options)
443	if err != nil {
444		return nil, err
445	}
446	resp, err := client.con.Pipeline().Do(req)
447	if err != nil {
448		return nil, err
449	}
450	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
451		return nil, client.prepareNetworkPoliciesHandleError(resp)
452	}
453	return resp, nil
454}
455
456// prepareNetworkPoliciesCreateRequest creates the PrepareNetworkPolicies request.
457func (client *SubnetsClient) prepareNetworkPoliciesCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, prepareNetworkPoliciesRequestParameters PrepareNetworkPoliciesRequest, options *SubnetsBeginPrepareNetworkPoliciesOptions) (*azcore.Request, error) {
458	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}/PrepareNetworkPolicies"
459	if resourceGroupName == "" {
460		return nil, errors.New("parameter resourceGroupName cannot be empty")
461	}
462	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
463	if virtualNetworkName == "" {
464		return nil, errors.New("parameter virtualNetworkName cannot be empty")
465	}
466	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
467	if subnetName == "" {
468		return nil, errors.New("parameter subnetName cannot be empty")
469	}
470	urlPath = strings.ReplaceAll(urlPath, "{subnetName}", url.PathEscape(subnetName))
471	if client.subscriptionID == "" {
472		return nil, errors.New("parameter client.subscriptionID cannot be empty")
473	}
474	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
475	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
476	if err != nil {
477		return nil, err
478	}
479	req.Telemetry(telemetryInfo)
480	reqQP := req.URL.Query()
481	reqQP.Set("api-version", "2021-02-01")
482	req.URL.RawQuery = reqQP.Encode()
483	req.Header.Set("Accept", "application/json")
484	return req, req.MarshalAsJSON(prepareNetworkPoliciesRequestParameters)
485}
486
487// prepareNetworkPoliciesHandleError handles the PrepareNetworkPolicies error response.
488func (client *SubnetsClient) prepareNetworkPoliciesHandleError(resp *azcore.Response) error {
489	body, err := resp.Payload()
490	if err != nil {
491		return azcore.NewResponseError(err, resp.Response)
492	}
493	errType := CloudError{raw: string(body)}
494	if err := resp.UnmarshalAsJSON(&errType); err != nil {
495		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
496	}
497	return azcore.NewResponseError(&errType, resp.Response)
498}
499
500// BeginUnprepareNetworkPolicies - Unprepares a subnet by removing network intent policies.
501// If the operation fails it returns the *CloudError error type.
502func (client *SubnetsClient) BeginUnprepareNetworkPolicies(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, unprepareNetworkPoliciesRequestParameters UnprepareNetworkPoliciesRequest, options *SubnetsBeginUnprepareNetworkPoliciesOptions) (HTTPPollerResponse, error) {
503	resp, err := client.unprepareNetworkPolicies(ctx, resourceGroupName, virtualNetworkName, subnetName, unprepareNetworkPoliciesRequestParameters, options)
504	if err != nil {
505		return HTTPPollerResponse{}, err
506	}
507	result := HTTPPollerResponse{
508		RawResponse: resp.Response,
509	}
510	pt, err := armcore.NewLROPoller("SubnetsClient.UnprepareNetworkPolicies", "location", resp, client.con.Pipeline(), client.unprepareNetworkPoliciesHandleError)
511	if err != nil {
512		return HTTPPollerResponse{}, err
513	}
514	poller := &httpPoller{
515		pt: pt,
516	}
517	result.Poller = poller
518	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
519		return poller.pollUntilDone(ctx, frequency)
520	}
521	return result, nil
522}
523
524// ResumeUnprepareNetworkPolicies creates a new HTTPPoller from the specified resume token.
525// token - The value must come from a previous call to HTTPPoller.ResumeToken().
526func (client *SubnetsClient) ResumeUnprepareNetworkPolicies(ctx context.Context, token string) (HTTPPollerResponse, error) {
527	pt, err := armcore.NewLROPollerFromResumeToken("SubnetsClient.UnprepareNetworkPolicies", token, client.con.Pipeline(), client.unprepareNetworkPoliciesHandleError)
528	if err != nil {
529		return HTTPPollerResponse{}, err
530	}
531	poller := &httpPoller{
532		pt: pt,
533	}
534	resp, err := poller.Poll(ctx)
535	if err != nil {
536		return HTTPPollerResponse{}, err
537	}
538	result := HTTPPollerResponse{
539		RawResponse: resp,
540	}
541	result.Poller = poller
542	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
543		return poller.pollUntilDone(ctx, frequency)
544	}
545	return result, nil
546}
547
548// UnprepareNetworkPolicies - Unprepares a subnet by removing network intent policies.
549// If the operation fails it returns the *CloudError error type.
550func (client *SubnetsClient) unprepareNetworkPolicies(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, unprepareNetworkPoliciesRequestParameters UnprepareNetworkPoliciesRequest, options *SubnetsBeginUnprepareNetworkPoliciesOptions) (*azcore.Response, error) {
551	req, err := client.unprepareNetworkPoliciesCreateRequest(ctx, resourceGroupName, virtualNetworkName, subnetName, unprepareNetworkPoliciesRequestParameters, options)
552	if err != nil {
553		return nil, err
554	}
555	resp, err := client.con.Pipeline().Do(req)
556	if err != nil {
557		return nil, err
558	}
559	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
560		return nil, client.unprepareNetworkPoliciesHandleError(resp)
561	}
562	return resp, nil
563}
564
565// unprepareNetworkPoliciesCreateRequest creates the UnprepareNetworkPolicies request.
566func (client *SubnetsClient) unprepareNetworkPoliciesCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, unprepareNetworkPoliciesRequestParameters UnprepareNetworkPoliciesRequest, options *SubnetsBeginUnprepareNetworkPoliciesOptions) (*azcore.Request, error) {
567	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}/UnprepareNetworkPolicies"
568	if resourceGroupName == "" {
569		return nil, errors.New("parameter resourceGroupName cannot be empty")
570	}
571	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
572	if virtualNetworkName == "" {
573		return nil, errors.New("parameter virtualNetworkName cannot be empty")
574	}
575	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
576	if subnetName == "" {
577		return nil, errors.New("parameter subnetName cannot be empty")
578	}
579	urlPath = strings.ReplaceAll(urlPath, "{subnetName}", url.PathEscape(subnetName))
580	if client.subscriptionID == "" {
581		return nil, errors.New("parameter client.subscriptionID cannot be empty")
582	}
583	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
584	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
585	if err != nil {
586		return nil, err
587	}
588	req.Telemetry(telemetryInfo)
589	reqQP := req.URL.Query()
590	reqQP.Set("api-version", "2021-02-01")
591	req.URL.RawQuery = reqQP.Encode()
592	req.Header.Set("Accept", "application/json")
593	return req, req.MarshalAsJSON(unprepareNetworkPoliciesRequestParameters)
594}
595
596// unprepareNetworkPoliciesHandleError handles the UnprepareNetworkPolicies error response.
597func (client *SubnetsClient) unprepareNetworkPoliciesHandleError(resp *azcore.Response) error {
598	body, err := resp.Payload()
599	if err != nil {
600		return azcore.NewResponseError(err, resp.Response)
601	}
602	errType := CloudError{raw: string(body)}
603	if err := resp.UnmarshalAsJSON(&errType); err != nil {
604		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
605	}
606	return azcore.NewResponseError(&errType, resp.Response)
607}
608