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// ExpressRouteCircuitsClient contains the methods for the ExpressRouteCircuits group.
23// Don't use this type directly, use NewExpressRouteCircuitsClient() instead.
24type ExpressRouteCircuitsClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewExpressRouteCircuitsClient creates a new instance of ExpressRouteCircuitsClient with the specified values.
30func NewExpressRouteCircuitsClient(con *armcore.Connection, subscriptionID string) *ExpressRouteCircuitsClient {
31	return &ExpressRouteCircuitsClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreateOrUpdate - Creates or updates an express route circuit.
35// If the operation fails it returns the *CloudError error type.
36func (client *ExpressRouteCircuitsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit, options *ExpressRouteCircuitsBeginCreateOrUpdateOptions) (ExpressRouteCircuitPollerResponse, error) {
37	resp, err := client.createOrUpdate(ctx, resourceGroupName, circuitName, parameters, options)
38	if err != nil {
39		return ExpressRouteCircuitPollerResponse{}, err
40	}
41	result := ExpressRouteCircuitPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("ExpressRouteCircuitsClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
45	if err != nil {
46		return ExpressRouteCircuitPollerResponse{}, err
47	}
48	poller := &expressRouteCircuitPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreateOrUpdate creates a new ExpressRouteCircuitPoller from the specified resume token.
59// token - The value must come from a previous call to ExpressRouteCircuitPoller.ResumeToken().
60func (client *ExpressRouteCircuitsClient) ResumeCreateOrUpdate(ctx context.Context, token string) (ExpressRouteCircuitPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCircuitsClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
62	if err != nil {
63		return ExpressRouteCircuitPollerResponse{}, err
64	}
65	poller := &expressRouteCircuitPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return ExpressRouteCircuitPollerResponse{}, err
71	}
72	result := ExpressRouteCircuitPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// CreateOrUpdate - Creates or updates an express route circuit.
83// If the operation fails it returns the *CloudError error type.
84func (client *ExpressRouteCircuitsClient) createOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit, options *ExpressRouteCircuitsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
85	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, circuitName, parameters, 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 *ExpressRouteCircuitsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit, options *ExpressRouteCircuitsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}"
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 circuitName == "" {
107		return nil, errors.New("parameter circuitName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
110	if client.subscriptionID == "" {
111		return nil, errors.New("parameter client.subscriptionID cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
114	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
115	if err != nil {
116		return nil, err
117	}
118	req.Telemetry(telemetryInfo)
119	reqQP := req.URL.Query()
120	reqQP.Set("api-version", "2021-02-01")
121	req.URL.RawQuery = reqQP.Encode()
122	req.Header.Set("Accept", "application/json")
123	return req, req.MarshalAsJSON(parameters)
124}
125
126// createOrUpdateHandleError handles the CreateOrUpdate error response.
127func (client *ExpressRouteCircuitsClient) createOrUpdateHandleError(resp *azcore.Response) error {
128	body, err := resp.Payload()
129	if err != nil {
130		return azcore.NewResponseError(err, resp.Response)
131	}
132	errType := CloudError{raw: string(body)}
133	if err := resp.UnmarshalAsJSON(&errType); err != nil {
134		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
135	}
136	return azcore.NewResponseError(&errType, resp.Response)
137}
138
139// BeginDelete - Deletes the specified express route circuit.
140// If the operation fails it returns the *CloudError error type.
141func (client *ExpressRouteCircuitsClient) BeginDelete(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsBeginDeleteOptions) (HTTPPollerResponse, error) {
142	resp, err := client.deleteOperation(ctx, resourceGroupName, circuitName, options)
143	if err != nil {
144		return HTTPPollerResponse{}, err
145	}
146	result := HTTPPollerResponse{
147		RawResponse: resp.Response,
148	}
149	pt, err := armcore.NewLROPoller("ExpressRouteCircuitsClient.Delete", "location", resp, client.con.Pipeline(), client.deleteHandleError)
150	if err != nil {
151		return HTTPPollerResponse{}, err
152	}
153	poller := &httpPoller{
154		pt: pt,
155	}
156	result.Poller = poller
157	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
158		return poller.pollUntilDone(ctx, frequency)
159	}
160	return result, nil
161}
162
163// ResumeDelete creates a new HTTPPoller from the specified resume token.
164// token - The value must come from a previous call to HTTPPoller.ResumeToken().
165func (client *ExpressRouteCircuitsClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
166	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCircuitsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
167	if err != nil {
168		return HTTPPollerResponse{}, err
169	}
170	poller := &httpPoller{
171		pt: pt,
172	}
173	resp, err := poller.Poll(ctx)
174	if err != nil {
175		return HTTPPollerResponse{}, err
176	}
177	result := HTTPPollerResponse{
178		RawResponse: resp,
179	}
180	result.Poller = poller
181	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
182		return poller.pollUntilDone(ctx, frequency)
183	}
184	return result, nil
185}
186
187// Delete - Deletes the specified express route circuit.
188// If the operation fails it returns the *CloudError error type.
189func (client *ExpressRouteCircuitsClient) deleteOperation(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsBeginDeleteOptions) (*azcore.Response, error) {
190	req, err := client.deleteCreateRequest(ctx, resourceGroupName, circuitName, options)
191	if err != nil {
192		return nil, err
193	}
194	resp, err := client.con.Pipeline().Do(req)
195	if err != nil {
196		return nil, err
197	}
198	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
199		return nil, client.deleteHandleError(resp)
200	}
201	return resp, nil
202}
203
204// deleteCreateRequest creates the Delete request.
205func (client *ExpressRouteCircuitsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsBeginDeleteOptions) (*azcore.Request, error) {
206	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}"
207	if resourceGroupName == "" {
208		return nil, errors.New("parameter resourceGroupName cannot be empty")
209	}
210	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
211	if circuitName == "" {
212		return nil, errors.New("parameter circuitName cannot be empty")
213	}
214	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
215	if client.subscriptionID == "" {
216		return nil, errors.New("parameter client.subscriptionID cannot be empty")
217	}
218	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
219	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
220	if err != nil {
221		return nil, err
222	}
223	req.Telemetry(telemetryInfo)
224	reqQP := req.URL.Query()
225	reqQP.Set("api-version", "2021-02-01")
226	req.URL.RawQuery = reqQP.Encode()
227	req.Header.Set("Accept", "application/json")
228	return req, nil
229}
230
231// deleteHandleError handles the Delete error response.
232func (client *ExpressRouteCircuitsClient) deleteHandleError(resp *azcore.Response) error {
233	body, err := resp.Payload()
234	if err != nil {
235		return azcore.NewResponseError(err, resp.Response)
236	}
237	errType := CloudError{raw: string(body)}
238	if err := resp.UnmarshalAsJSON(&errType); err != nil {
239		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
240	}
241	return azcore.NewResponseError(&errType, resp.Response)
242}
243
244// Get - Gets information about the specified express route circuit.
245// If the operation fails it returns the *CloudError error type.
246func (client *ExpressRouteCircuitsClient) Get(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsGetOptions) (ExpressRouteCircuitResponse, error) {
247	req, err := client.getCreateRequest(ctx, resourceGroupName, circuitName, options)
248	if err != nil {
249		return ExpressRouteCircuitResponse{}, err
250	}
251	resp, err := client.con.Pipeline().Do(req)
252	if err != nil {
253		return ExpressRouteCircuitResponse{}, err
254	}
255	if !resp.HasStatusCode(http.StatusOK) {
256		return ExpressRouteCircuitResponse{}, client.getHandleError(resp)
257	}
258	return client.getHandleResponse(resp)
259}
260
261// getCreateRequest creates the Get request.
262func (client *ExpressRouteCircuitsClient) getCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsGetOptions) (*azcore.Request, error) {
263	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}"
264	if resourceGroupName == "" {
265		return nil, errors.New("parameter resourceGroupName cannot be empty")
266	}
267	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
268	if circuitName == "" {
269		return nil, errors.New("parameter circuitName cannot be empty")
270	}
271	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
272	if client.subscriptionID == "" {
273		return nil, errors.New("parameter client.subscriptionID cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
276	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
277	if err != nil {
278		return nil, err
279	}
280	req.Telemetry(telemetryInfo)
281	reqQP := req.URL.Query()
282	reqQP.Set("api-version", "2021-02-01")
283	req.URL.RawQuery = reqQP.Encode()
284	req.Header.Set("Accept", "application/json")
285	return req, nil
286}
287
288// getHandleResponse handles the Get response.
289func (client *ExpressRouteCircuitsClient) getHandleResponse(resp *azcore.Response) (ExpressRouteCircuitResponse, error) {
290	var val *ExpressRouteCircuit
291	if err := resp.UnmarshalAsJSON(&val); err != nil {
292		return ExpressRouteCircuitResponse{}, err
293	}
294	return ExpressRouteCircuitResponse{RawResponse: resp.Response, ExpressRouteCircuit: val}, nil
295}
296
297// getHandleError handles the Get error response.
298func (client *ExpressRouteCircuitsClient) getHandleError(resp *azcore.Response) error {
299	body, err := resp.Payload()
300	if err != nil {
301		return azcore.NewResponseError(err, resp.Response)
302	}
303	errType := CloudError{raw: string(body)}
304	if err := resp.UnmarshalAsJSON(&errType); err != nil {
305		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
306	}
307	return azcore.NewResponseError(&errType, resp.Response)
308}
309
310// GetPeeringStats - Gets all stats from an express route circuit in a resource group.
311// If the operation fails it returns the *CloudError error type.
312func (client *ExpressRouteCircuitsClient) GetPeeringStats(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, options *ExpressRouteCircuitsGetPeeringStatsOptions) (ExpressRouteCircuitStatsResponse, error) {
313	req, err := client.getPeeringStatsCreateRequest(ctx, resourceGroupName, circuitName, peeringName, options)
314	if err != nil {
315		return ExpressRouteCircuitStatsResponse{}, err
316	}
317	resp, err := client.con.Pipeline().Do(req)
318	if err != nil {
319		return ExpressRouteCircuitStatsResponse{}, err
320	}
321	if !resp.HasStatusCode(http.StatusOK) {
322		return ExpressRouteCircuitStatsResponse{}, client.getPeeringStatsHandleError(resp)
323	}
324	return client.getPeeringStatsHandleResponse(resp)
325}
326
327// getPeeringStatsCreateRequest creates the GetPeeringStats request.
328func (client *ExpressRouteCircuitsClient) getPeeringStatsCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, options *ExpressRouteCircuitsGetPeeringStatsOptions) (*azcore.Request, error) {
329	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/stats"
330	if resourceGroupName == "" {
331		return nil, errors.New("parameter resourceGroupName cannot be empty")
332	}
333	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
334	if circuitName == "" {
335		return nil, errors.New("parameter circuitName cannot be empty")
336	}
337	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
338	if peeringName == "" {
339		return nil, errors.New("parameter peeringName cannot be empty")
340	}
341	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
342	if client.subscriptionID == "" {
343		return nil, errors.New("parameter client.subscriptionID cannot be empty")
344	}
345	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
346	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
347	if err != nil {
348		return nil, err
349	}
350	req.Telemetry(telemetryInfo)
351	reqQP := req.URL.Query()
352	reqQP.Set("api-version", "2021-02-01")
353	req.URL.RawQuery = reqQP.Encode()
354	req.Header.Set("Accept", "application/json")
355	return req, nil
356}
357
358// getPeeringStatsHandleResponse handles the GetPeeringStats response.
359func (client *ExpressRouteCircuitsClient) getPeeringStatsHandleResponse(resp *azcore.Response) (ExpressRouteCircuitStatsResponse, error) {
360	var val *ExpressRouteCircuitStats
361	if err := resp.UnmarshalAsJSON(&val); err != nil {
362		return ExpressRouteCircuitStatsResponse{}, err
363	}
364	return ExpressRouteCircuitStatsResponse{RawResponse: resp.Response, ExpressRouteCircuitStats: val}, nil
365}
366
367// getPeeringStatsHandleError handles the GetPeeringStats error response.
368func (client *ExpressRouteCircuitsClient) getPeeringStatsHandleError(resp *azcore.Response) error {
369	body, err := resp.Payload()
370	if err != nil {
371		return azcore.NewResponseError(err, resp.Response)
372	}
373	errType := CloudError{raw: string(body)}
374	if err := resp.UnmarshalAsJSON(&errType); err != nil {
375		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
376	}
377	return azcore.NewResponseError(&errType, resp.Response)
378}
379
380// GetStats - Gets all the stats from an express route circuit in a resource group.
381// If the operation fails it returns the *CloudError error type.
382func (client *ExpressRouteCircuitsClient) GetStats(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsGetStatsOptions) (ExpressRouteCircuitStatsResponse, error) {
383	req, err := client.getStatsCreateRequest(ctx, resourceGroupName, circuitName, options)
384	if err != nil {
385		return ExpressRouteCircuitStatsResponse{}, err
386	}
387	resp, err := client.con.Pipeline().Do(req)
388	if err != nil {
389		return ExpressRouteCircuitStatsResponse{}, err
390	}
391	if !resp.HasStatusCode(http.StatusOK) {
392		return ExpressRouteCircuitStatsResponse{}, client.getStatsHandleError(resp)
393	}
394	return client.getStatsHandleResponse(resp)
395}
396
397// getStatsCreateRequest creates the GetStats request.
398func (client *ExpressRouteCircuitsClient) getStatsCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, options *ExpressRouteCircuitsGetStatsOptions) (*azcore.Request, error) {
399	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/stats"
400	if resourceGroupName == "" {
401		return nil, errors.New("parameter resourceGroupName cannot be empty")
402	}
403	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
404	if circuitName == "" {
405		return nil, errors.New("parameter circuitName cannot be empty")
406	}
407	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
408	if client.subscriptionID == "" {
409		return nil, errors.New("parameter client.subscriptionID cannot be empty")
410	}
411	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
412	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
413	if err != nil {
414		return nil, err
415	}
416	req.Telemetry(telemetryInfo)
417	reqQP := req.URL.Query()
418	reqQP.Set("api-version", "2021-02-01")
419	req.URL.RawQuery = reqQP.Encode()
420	req.Header.Set("Accept", "application/json")
421	return req, nil
422}
423
424// getStatsHandleResponse handles the GetStats response.
425func (client *ExpressRouteCircuitsClient) getStatsHandleResponse(resp *azcore.Response) (ExpressRouteCircuitStatsResponse, error) {
426	var val *ExpressRouteCircuitStats
427	if err := resp.UnmarshalAsJSON(&val); err != nil {
428		return ExpressRouteCircuitStatsResponse{}, err
429	}
430	return ExpressRouteCircuitStatsResponse{RawResponse: resp.Response, ExpressRouteCircuitStats: val}, nil
431}
432
433// getStatsHandleError handles the GetStats error response.
434func (client *ExpressRouteCircuitsClient) getStatsHandleError(resp *azcore.Response) error {
435	body, err := resp.Payload()
436	if err != nil {
437		return azcore.NewResponseError(err, resp.Response)
438	}
439	errType := CloudError{raw: string(body)}
440	if err := resp.UnmarshalAsJSON(&errType); err != nil {
441		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
442	}
443	return azcore.NewResponseError(&errType, resp.Response)
444}
445
446// List - Gets all the express route circuits in a resource group.
447// If the operation fails it returns the *CloudError error type.
448func (client *ExpressRouteCircuitsClient) List(resourceGroupName string, options *ExpressRouteCircuitsListOptions) ExpressRouteCircuitListResultPager {
449	return &expressRouteCircuitListResultPager{
450		pipeline: client.con.Pipeline(),
451		requester: func(ctx context.Context) (*azcore.Request, error) {
452			return client.listCreateRequest(ctx, resourceGroupName, options)
453		},
454		responder: client.listHandleResponse,
455		errorer:   client.listHandleError,
456		advancer: func(ctx context.Context, resp ExpressRouteCircuitListResultResponse) (*azcore.Request, error) {
457			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRouteCircuitListResult.NextLink)
458		},
459		statusCodes: []int{http.StatusOK},
460	}
461}
462
463// listCreateRequest creates the List request.
464func (client *ExpressRouteCircuitsClient) listCreateRequest(ctx context.Context, resourceGroupName string, options *ExpressRouteCircuitsListOptions) (*azcore.Request, error) {
465	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits"
466	if resourceGroupName == "" {
467		return nil, errors.New("parameter resourceGroupName cannot be empty")
468	}
469	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
470	if client.subscriptionID == "" {
471		return nil, errors.New("parameter client.subscriptionID cannot be empty")
472	}
473	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
474	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
475	if err != nil {
476		return nil, err
477	}
478	req.Telemetry(telemetryInfo)
479	reqQP := req.URL.Query()
480	reqQP.Set("api-version", "2021-02-01")
481	req.URL.RawQuery = reqQP.Encode()
482	req.Header.Set("Accept", "application/json")
483	return req, nil
484}
485
486// listHandleResponse handles the List response.
487func (client *ExpressRouteCircuitsClient) listHandleResponse(resp *azcore.Response) (ExpressRouteCircuitListResultResponse, error) {
488	var val *ExpressRouteCircuitListResult
489	if err := resp.UnmarshalAsJSON(&val); err != nil {
490		return ExpressRouteCircuitListResultResponse{}, err
491	}
492	return ExpressRouteCircuitListResultResponse{RawResponse: resp.Response, ExpressRouteCircuitListResult: val}, nil
493}
494
495// listHandleError handles the List error response.
496func (client *ExpressRouteCircuitsClient) listHandleError(resp *azcore.Response) error {
497	body, err := resp.Payload()
498	if err != nil {
499		return azcore.NewResponseError(err, resp.Response)
500	}
501	errType := CloudError{raw: string(body)}
502	if err := resp.UnmarshalAsJSON(&errType); err != nil {
503		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
504	}
505	return azcore.NewResponseError(&errType, resp.Response)
506}
507
508// ListAll - Gets all the express route circuits in a subscription.
509// If the operation fails it returns the *CloudError error type.
510func (client *ExpressRouteCircuitsClient) ListAll(options *ExpressRouteCircuitsListAllOptions) ExpressRouteCircuitListResultPager {
511	return &expressRouteCircuitListResultPager{
512		pipeline: client.con.Pipeline(),
513		requester: func(ctx context.Context) (*azcore.Request, error) {
514			return client.listAllCreateRequest(ctx, options)
515		},
516		responder: client.listAllHandleResponse,
517		errorer:   client.listAllHandleError,
518		advancer: func(ctx context.Context, resp ExpressRouteCircuitListResultResponse) (*azcore.Request, error) {
519			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRouteCircuitListResult.NextLink)
520		},
521		statusCodes: []int{http.StatusOK},
522	}
523}
524
525// listAllCreateRequest creates the ListAll request.
526func (client *ExpressRouteCircuitsClient) listAllCreateRequest(ctx context.Context, options *ExpressRouteCircuitsListAllOptions) (*azcore.Request, error) {
527	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/expressRouteCircuits"
528	if client.subscriptionID == "" {
529		return nil, errors.New("parameter client.subscriptionID cannot be empty")
530	}
531	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
532	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
533	if err != nil {
534		return nil, err
535	}
536	req.Telemetry(telemetryInfo)
537	reqQP := req.URL.Query()
538	reqQP.Set("api-version", "2021-02-01")
539	req.URL.RawQuery = reqQP.Encode()
540	req.Header.Set("Accept", "application/json")
541	return req, nil
542}
543
544// listAllHandleResponse handles the ListAll response.
545func (client *ExpressRouteCircuitsClient) listAllHandleResponse(resp *azcore.Response) (ExpressRouteCircuitListResultResponse, error) {
546	var val *ExpressRouteCircuitListResult
547	if err := resp.UnmarshalAsJSON(&val); err != nil {
548		return ExpressRouteCircuitListResultResponse{}, err
549	}
550	return ExpressRouteCircuitListResultResponse{RawResponse: resp.Response, ExpressRouteCircuitListResult: val}, nil
551}
552
553// listAllHandleError handles the ListAll error response.
554func (client *ExpressRouteCircuitsClient) listAllHandleError(resp *azcore.Response) error {
555	body, err := resp.Payload()
556	if err != nil {
557		return azcore.NewResponseError(err, resp.Response)
558	}
559	errType := CloudError{raw: string(body)}
560	if err := resp.UnmarshalAsJSON(&errType); err != nil {
561		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
562	}
563	return azcore.NewResponseError(&errType, resp.Response)
564}
565
566// BeginListArpTable - Gets the currently advertised ARP table associated with the express route circuit in a resource group.
567// If the operation fails it returns the *CloudError error type.
568func (client *ExpressRouteCircuitsClient) BeginListArpTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListArpTableOptions) (ExpressRouteCircuitsArpTableListResultPollerResponse, error) {
569	resp, err := client.listArpTable(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
570	if err != nil {
571		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
572	}
573	result := ExpressRouteCircuitsArpTableListResultPollerResponse{
574		RawResponse: resp.Response,
575	}
576	pt, err := armcore.NewLROPoller("ExpressRouteCircuitsClient.ListArpTable", "location", resp, client.con.Pipeline(), client.listArpTableHandleError)
577	if err != nil {
578		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
579	}
580	poller := &expressRouteCircuitsArpTableListResultPoller{
581		pt: pt,
582	}
583	result.Poller = poller
584	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsArpTableListResultResponse, error) {
585		return poller.pollUntilDone(ctx, frequency)
586	}
587	return result, nil
588}
589
590// ResumeListArpTable creates a new ExpressRouteCircuitsArpTableListResultPoller from the specified resume token.
591// token - The value must come from a previous call to ExpressRouteCircuitsArpTableListResultPoller.ResumeToken().
592func (client *ExpressRouteCircuitsClient) ResumeListArpTable(ctx context.Context, token string) (ExpressRouteCircuitsArpTableListResultPollerResponse, error) {
593	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCircuitsClient.ListArpTable", token, client.con.Pipeline(), client.listArpTableHandleError)
594	if err != nil {
595		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
596	}
597	poller := &expressRouteCircuitsArpTableListResultPoller{
598		pt: pt,
599	}
600	resp, err := poller.Poll(ctx)
601	if err != nil {
602		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
603	}
604	result := ExpressRouteCircuitsArpTableListResultPollerResponse{
605		RawResponse: resp,
606	}
607	result.Poller = poller
608	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsArpTableListResultResponse, error) {
609		return poller.pollUntilDone(ctx, frequency)
610	}
611	return result, nil
612}
613
614// ListArpTable - Gets the currently advertised ARP table associated with the express route circuit in a resource group.
615// If the operation fails it returns the *CloudError error type.
616func (client *ExpressRouteCircuitsClient) listArpTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListArpTableOptions) (*azcore.Response, error) {
617	req, err := client.listArpTableCreateRequest(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
618	if err != nil {
619		return nil, err
620	}
621	resp, err := client.con.Pipeline().Do(req)
622	if err != nil {
623		return nil, err
624	}
625	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
626		return nil, client.listArpTableHandleError(resp)
627	}
628	return resp, nil
629}
630
631// listArpTableCreateRequest creates the ListArpTable request.
632func (client *ExpressRouteCircuitsClient) listArpTableCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListArpTableOptions) (*azcore.Request, error) {
633	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/arpTables/{devicePath}"
634	if resourceGroupName == "" {
635		return nil, errors.New("parameter resourceGroupName cannot be empty")
636	}
637	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
638	if circuitName == "" {
639		return nil, errors.New("parameter circuitName cannot be empty")
640	}
641	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
642	if peeringName == "" {
643		return nil, errors.New("parameter peeringName cannot be empty")
644	}
645	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
646	if devicePath == "" {
647		return nil, errors.New("parameter devicePath cannot be empty")
648	}
649	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
650	if client.subscriptionID == "" {
651		return nil, errors.New("parameter client.subscriptionID cannot be empty")
652	}
653	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
654	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
655	if err != nil {
656		return nil, err
657	}
658	req.Telemetry(telemetryInfo)
659	reqQP := req.URL.Query()
660	reqQP.Set("api-version", "2021-02-01")
661	req.URL.RawQuery = reqQP.Encode()
662	req.Header.Set("Accept", "application/json")
663	return req, nil
664}
665
666// listArpTableHandleError handles the ListArpTable error response.
667func (client *ExpressRouteCircuitsClient) listArpTableHandleError(resp *azcore.Response) error {
668	body, err := resp.Payload()
669	if err != nil {
670		return azcore.NewResponseError(err, resp.Response)
671	}
672	errType := CloudError{raw: string(body)}
673	if err := resp.UnmarshalAsJSON(&errType); err != nil {
674		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
675	}
676	return azcore.NewResponseError(&errType, resp.Response)
677}
678
679// BeginListRoutesTable - Gets the currently advertised routes table associated with the express route circuit in a resource group.
680// If the operation fails it returns the *CloudError error type.
681func (client *ExpressRouteCircuitsClient) BeginListRoutesTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableOptions) (ExpressRouteCircuitsRoutesTableListResultPollerResponse, error) {
682	resp, err := client.listRoutesTable(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
683	if err != nil {
684		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
685	}
686	result := ExpressRouteCircuitsRoutesTableListResultPollerResponse{
687		RawResponse: resp.Response,
688	}
689	pt, err := armcore.NewLROPoller("ExpressRouteCircuitsClient.ListRoutesTable", "location", resp, client.con.Pipeline(), client.listRoutesTableHandleError)
690	if err != nil {
691		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
692	}
693	poller := &expressRouteCircuitsRoutesTableListResultPoller{
694		pt: pt,
695	}
696	result.Poller = poller
697	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
698		return poller.pollUntilDone(ctx, frequency)
699	}
700	return result, nil
701}
702
703// ResumeListRoutesTable creates a new ExpressRouteCircuitsRoutesTableListResultPoller from the specified resume token.
704// token - The value must come from a previous call to ExpressRouteCircuitsRoutesTableListResultPoller.ResumeToken().
705func (client *ExpressRouteCircuitsClient) ResumeListRoutesTable(ctx context.Context, token string) (ExpressRouteCircuitsRoutesTableListResultPollerResponse, error) {
706	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCircuitsClient.ListRoutesTable", token, client.con.Pipeline(), client.listRoutesTableHandleError)
707	if err != nil {
708		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
709	}
710	poller := &expressRouteCircuitsRoutesTableListResultPoller{
711		pt: pt,
712	}
713	resp, err := poller.Poll(ctx)
714	if err != nil {
715		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
716	}
717	result := ExpressRouteCircuitsRoutesTableListResultPollerResponse{
718		RawResponse: resp,
719	}
720	result.Poller = poller
721	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
722		return poller.pollUntilDone(ctx, frequency)
723	}
724	return result, nil
725}
726
727// ListRoutesTable - Gets the currently advertised routes table associated with the express route circuit in a resource group.
728// If the operation fails it returns the *CloudError error type.
729func (client *ExpressRouteCircuitsClient) listRoutesTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableOptions) (*azcore.Response, error) {
730	req, err := client.listRoutesTableCreateRequest(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
731	if err != nil {
732		return nil, err
733	}
734	resp, err := client.con.Pipeline().Do(req)
735	if err != nil {
736		return nil, err
737	}
738	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
739		return nil, client.listRoutesTableHandleError(resp)
740	}
741	return resp, nil
742}
743
744// listRoutesTableCreateRequest creates the ListRoutesTable request.
745func (client *ExpressRouteCircuitsClient) listRoutesTableCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableOptions) (*azcore.Request, error) {
746	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTables/{devicePath}"
747	if resourceGroupName == "" {
748		return nil, errors.New("parameter resourceGroupName cannot be empty")
749	}
750	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
751	if circuitName == "" {
752		return nil, errors.New("parameter circuitName cannot be empty")
753	}
754	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
755	if peeringName == "" {
756		return nil, errors.New("parameter peeringName cannot be empty")
757	}
758	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
759	if devicePath == "" {
760		return nil, errors.New("parameter devicePath cannot be empty")
761	}
762	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
763	if client.subscriptionID == "" {
764		return nil, errors.New("parameter client.subscriptionID cannot be empty")
765	}
766	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
767	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
768	if err != nil {
769		return nil, err
770	}
771	req.Telemetry(telemetryInfo)
772	reqQP := req.URL.Query()
773	reqQP.Set("api-version", "2021-02-01")
774	req.URL.RawQuery = reqQP.Encode()
775	req.Header.Set("Accept", "application/json")
776	return req, nil
777}
778
779// listRoutesTableHandleError handles the ListRoutesTable error response.
780func (client *ExpressRouteCircuitsClient) listRoutesTableHandleError(resp *azcore.Response) error {
781	body, err := resp.Payload()
782	if err != nil {
783		return azcore.NewResponseError(err, resp.Response)
784	}
785	errType := CloudError{raw: string(body)}
786	if err := resp.UnmarshalAsJSON(&errType); err != nil {
787		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
788	}
789	return azcore.NewResponseError(&errType, resp.Response)
790}
791
792// BeginListRoutesTableSummary - Gets the currently advertised routes table summary associated with the express route circuit in a resource group.
793// If the operation fails it returns the *CloudError error type.
794func (client *ExpressRouteCircuitsClient) BeginListRoutesTableSummary(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableSummaryOptions) (ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse, error) {
795	resp, err := client.listRoutesTableSummary(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
796	if err != nil {
797		return ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{}, err
798	}
799	result := ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{
800		RawResponse: resp.Response,
801	}
802	pt, err := armcore.NewLROPoller("ExpressRouteCircuitsClient.ListRoutesTableSummary", "location", resp, client.con.Pipeline(), client.listRoutesTableSummaryHandleError)
803	if err != nil {
804		return ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{}, err
805	}
806	poller := &expressRouteCircuitsRoutesTableSummaryListResultPoller{
807		pt: pt,
808	}
809	result.Poller = poller
810	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableSummaryListResultResponse, error) {
811		return poller.pollUntilDone(ctx, frequency)
812	}
813	return result, nil
814}
815
816// ResumeListRoutesTableSummary creates a new ExpressRouteCircuitsRoutesTableSummaryListResultPoller from the specified resume token.
817// token - The value must come from a previous call to ExpressRouteCircuitsRoutesTableSummaryListResultPoller.ResumeToken().
818func (client *ExpressRouteCircuitsClient) ResumeListRoutesTableSummary(ctx context.Context, token string) (ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse, error) {
819	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCircuitsClient.ListRoutesTableSummary", token, client.con.Pipeline(), client.listRoutesTableSummaryHandleError)
820	if err != nil {
821		return ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{}, err
822	}
823	poller := &expressRouteCircuitsRoutesTableSummaryListResultPoller{
824		pt: pt,
825	}
826	resp, err := poller.Poll(ctx)
827	if err != nil {
828		return ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{}, err
829	}
830	result := ExpressRouteCircuitsRoutesTableSummaryListResultPollerResponse{
831		RawResponse: resp,
832	}
833	result.Poller = poller
834	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableSummaryListResultResponse, error) {
835		return poller.pollUntilDone(ctx, frequency)
836	}
837	return result, nil
838}
839
840// ListRoutesTableSummary - Gets the currently advertised routes table summary associated with the express route circuit in a resource group.
841// If the operation fails it returns the *CloudError error type.
842func (client *ExpressRouteCircuitsClient) listRoutesTableSummary(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableSummaryOptions) (*azcore.Response, error) {
843	req, err := client.listRoutesTableSummaryCreateRequest(ctx, resourceGroupName, circuitName, peeringName, devicePath, options)
844	if err != nil {
845		return nil, err
846	}
847	resp, err := client.con.Pipeline().Do(req)
848	if err != nil {
849		return nil, err
850	}
851	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
852		return nil, client.listRoutesTableSummaryHandleError(resp)
853	}
854	return resp, nil
855}
856
857// listRoutesTableSummaryCreateRequest creates the ListRoutesTableSummary request.
858func (client *ExpressRouteCircuitsClient) listRoutesTableSummaryCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string, options *ExpressRouteCircuitsBeginListRoutesTableSummaryOptions) (*azcore.Request, error) {
859	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTablesSummary/{devicePath}"
860	if resourceGroupName == "" {
861		return nil, errors.New("parameter resourceGroupName cannot be empty")
862	}
863	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
864	if circuitName == "" {
865		return nil, errors.New("parameter circuitName cannot be empty")
866	}
867	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
868	if peeringName == "" {
869		return nil, errors.New("parameter peeringName cannot be empty")
870	}
871	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
872	if devicePath == "" {
873		return nil, errors.New("parameter devicePath cannot be empty")
874	}
875	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
876	if client.subscriptionID == "" {
877		return nil, errors.New("parameter client.subscriptionID cannot be empty")
878	}
879	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
880	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
881	if err != nil {
882		return nil, err
883	}
884	req.Telemetry(telemetryInfo)
885	reqQP := req.URL.Query()
886	reqQP.Set("api-version", "2021-02-01")
887	req.URL.RawQuery = reqQP.Encode()
888	req.Header.Set("Accept", "application/json")
889	return req, nil
890}
891
892// listRoutesTableSummaryHandleError handles the ListRoutesTableSummary error response.
893func (client *ExpressRouteCircuitsClient) listRoutesTableSummaryHandleError(resp *azcore.Response) error {
894	body, err := resp.Payload()
895	if err != nil {
896		return azcore.NewResponseError(err, resp.Response)
897	}
898	errType := CloudError{raw: string(body)}
899	if err := resp.UnmarshalAsJSON(&errType); err != nil {
900		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
901	}
902	return azcore.NewResponseError(&errType, resp.Response)
903}
904
905// UpdateTags - Updates an express route circuit tags.
906// If the operation fails it returns the *CloudError error type.
907func (client *ExpressRouteCircuitsClient) UpdateTags(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject, options *ExpressRouteCircuitsUpdateTagsOptions) (ExpressRouteCircuitResponse, error) {
908	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, circuitName, parameters, options)
909	if err != nil {
910		return ExpressRouteCircuitResponse{}, err
911	}
912	resp, err := client.con.Pipeline().Do(req)
913	if err != nil {
914		return ExpressRouteCircuitResponse{}, err
915	}
916	if !resp.HasStatusCode(http.StatusOK) {
917		return ExpressRouteCircuitResponse{}, client.updateTagsHandleError(resp)
918	}
919	return client.updateTagsHandleResponse(resp)
920}
921
922// updateTagsCreateRequest creates the UpdateTags request.
923func (client *ExpressRouteCircuitsClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject, options *ExpressRouteCircuitsUpdateTagsOptions) (*azcore.Request, error) {
924	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}"
925	if resourceGroupName == "" {
926		return nil, errors.New("parameter resourceGroupName cannot be empty")
927	}
928	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
929	if circuitName == "" {
930		return nil, errors.New("parameter circuitName cannot be empty")
931	}
932	urlPath = strings.ReplaceAll(urlPath, "{circuitName}", url.PathEscape(circuitName))
933	if client.subscriptionID == "" {
934		return nil, errors.New("parameter client.subscriptionID cannot be empty")
935	}
936	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
937	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
938	if err != nil {
939		return nil, err
940	}
941	req.Telemetry(telemetryInfo)
942	reqQP := req.URL.Query()
943	reqQP.Set("api-version", "2021-02-01")
944	req.URL.RawQuery = reqQP.Encode()
945	req.Header.Set("Accept", "application/json")
946	return req, req.MarshalAsJSON(parameters)
947}
948
949// updateTagsHandleResponse handles the UpdateTags response.
950func (client *ExpressRouteCircuitsClient) updateTagsHandleResponse(resp *azcore.Response) (ExpressRouteCircuitResponse, error) {
951	var val *ExpressRouteCircuit
952	if err := resp.UnmarshalAsJSON(&val); err != nil {
953		return ExpressRouteCircuitResponse{}, err
954	}
955	return ExpressRouteCircuitResponse{RawResponse: resp.Response, ExpressRouteCircuit: val}, nil
956}
957
958// updateTagsHandleError handles the UpdateTags error response.
959func (client *ExpressRouteCircuitsClient) updateTagsHandleError(resp *azcore.Response) error {
960	body, err := resp.Payload()
961	if err != nil {
962		return azcore.NewResponseError(err, resp.Response)
963	}
964	errType := CloudError{raw: string(body)}
965	if err := resp.UnmarshalAsJSON(&errType); err != nil {
966		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
967	}
968	return azcore.NewResponseError(&errType, resp.Response)
969}
970