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