Source file src/github.com/Azure/azure-sdk-for-go/services/preview/iothub/mgmt/2021-03-03-preview/devices/iothubresource.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/iothub/mgmt/2021-03-03-preview/devices

     1  package devices
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/autorest/validation"
    14  	"github.com/Azure/go-autorest/tracing"
    15  	"net/http"
    16  )
    17  
    18  // IotHubResourceClient is the use this API to manage the IoT hubs in your Azure subscription.
    19  type IotHubResourceClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewIotHubResourceClient creates an instance of the IotHubResourceClient client.
    24  func NewIotHubResourceClient(subscriptionID string) IotHubResourceClient {
    25  	return NewIotHubResourceClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewIotHubResourceClientWithBaseURI creates an instance of the IotHubResourceClient client using a custom endpoint.
    29  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewIotHubResourceClientWithBaseURI(baseURI string, subscriptionID string) IotHubResourceClient {
    31  	return IotHubResourceClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CheckNameAvailability check if an IoT hub name is available.
    35  // Parameters:
    36  // operationInputs - set the name parameter in the OperationInputs structure to the name of the IoT hub to
    37  // check.
    38  func (client IotHubResourceClient) CheckNameAvailability(ctx context.Context, operationInputs OperationInputs) (result IotHubNameAvailabilityInfo, err error) {
    39  	if tracing.IsEnabled() {
    40  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CheckNameAvailability")
    41  		defer func() {
    42  			sc := -1
    43  			if result.Response.Response != nil {
    44  				sc = result.Response.Response.StatusCode
    45  			}
    46  			tracing.EndSpan(ctx, sc, err)
    47  		}()
    48  	}
    49  	if err := validation.Validate([]validation.Validation{
    50  		{TargetValue: operationInputs,
    51  			Constraints: []validation.Constraint{{Target: "operationInputs.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    52  		return result, validation.NewError("devices.IotHubResourceClient", "CheckNameAvailability", err.Error())
    53  	}
    54  
    55  	req, err := client.CheckNameAvailabilityPreparer(ctx, operationInputs)
    56  	if err != nil {
    57  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", nil, "Failure preparing request")
    58  		return
    59  	}
    60  
    61  	resp, err := client.CheckNameAvailabilitySender(req)
    62  	if err != nil {
    63  		result.Response = autorest.Response{Response: resp}
    64  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure sending request")
    65  		return
    66  	}
    67  
    68  	result, err = client.CheckNameAvailabilityResponder(resp)
    69  	if err != nil {
    70  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure responding to request")
    71  		return
    72  	}
    73  
    74  	return
    75  }
    76  
    77  // CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
    78  func (client IotHubResourceClient) CheckNameAvailabilityPreparer(ctx context.Context, operationInputs OperationInputs) (*http.Request, error) {
    79  	pathParameters := map[string]interface{}{
    80  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
    81  	}
    82  
    83  	const APIVersion = "2021-03-03-preview"
    84  	queryParameters := map[string]interface{}{
    85  		"api-version": APIVersion,
    86  	}
    87  
    88  	preparer := autorest.CreatePreparer(
    89  		autorest.AsContentType("application/json; charset=utf-8"),
    90  		autorest.AsPost(),
    91  		autorest.WithBaseURL(client.BaseURI),
    92  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/checkNameAvailability", pathParameters),
    93  		autorest.WithJSON(operationInputs),
    94  		autorest.WithQueryParameters(queryParameters))
    95  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    96  }
    97  
    98  // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
    99  // http.Response Body if it receives an error.
   100  func (client IotHubResourceClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
   101  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   102  }
   103  
   104  // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
   105  // closes the http.Response Body.
   106  func (client IotHubResourceClient) CheckNameAvailabilityResponder(resp *http.Response) (result IotHubNameAvailabilityInfo, err error) {
   107  	err = autorest.Respond(
   108  		resp,
   109  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   110  		autorest.ByUnmarshallingJSON(&result),
   111  		autorest.ByClosing())
   112  	result.Response = autorest.Response{Response: resp}
   113  	return
   114  }
   115  
   116  // CreateEventHubConsumerGroup add a consumer group to an Event Hub-compatible endpoint in an IoT hub.
   117  // Parameters:
   118  // resourceGroupName - the name of the resource group that contains the IoT hub.
   119  // resourceName - the name of the IoT hub.
   120  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   121  // name - the name of the consumer group to add.
   122  // consumerGroupBody - the consumer group to add.
   123  func (client IotHubResourceClient) CreateEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string, consumerGroupBody EventHubConsumerGroupBodyDescription) (result EventHubConsumerGroupInfo, err error) {
   124  	if tracing.IsEnabled() {
   125  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateEventHubConsumerGroup")
   126  		defer func() {
   127  			sc := -1
   128  			if result.Response.Response != nil {
   129  				sc = result.Response.Response.StatusCode
   130  			}
   131  			tracing.EndSpan(ctx, sc, err)
   132  		}()
   133  	}
   134  	req, err := client.CreateEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name, consumerGroupBody)
   135  	if err != nil {
   136  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", nil, "Failure preparing request")
   137  		return
   138  	}
   139  
   140  	resp, err := client.CreateEventHubConsumerGroupSender(req)
   141  	if err != nil {
   142  		result.Response = autorest.Response{Response: resp}
   143  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure sending request")
   144  		return
   145  	}
   146  
   147  	result, err = client.CreateEventHubConsumerGroupResponder(resp)
   148  	if err != nil {
   149  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure responding to request")
   150  		return
   151  	}
   152  
   153  	return
   154  }
   155  
   156  // CreateEventHubConsumerGroupPreparer prepares the CreateEventHubConsumerGroup request.
   157  func (client IotHubResourceClient) CreateEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string, consumerGroupBody EventHubConsumerGroupBodyDescription) (*http.Request, error) {
   158  	pathParameters := map[string]interface{}{
   159  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   160  		"name":                 autorest.Encode("path", name),
   161  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   162  		"resourceName":         autorest.Encode("path", resourceName),
   163  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   164  	}
   165  
   166  	const APIVersion = "2021-03-03-preview"
   167  	queryParameters := map[string]interface{}{
   168  		"api-version": APIVersion,
   169  	}
   170  
   171  	preparer := autorest.CreatePreparer(
   172  		autorest.AsContentType("application/json; charset=utf-8"),
   173  		autorest.AsPut(),
   174  		autorest.WithBaseURL(client.BaseURI),
   175  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   176  		autorest.WithJSON(consumerGroupBody),
   177  		autorest.WithQueryParameters(queryParameters))
   178  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   179  }
   180  
   181  // CreateEventHubConsumerGroupSender sends the CreateEventHubConsumerGroup request. The method will close the
   182  // http.Response Body if it receives an error.
   183  func (client IotHubResourceClient) CreateEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   184  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   185  }
   186  
   187  // CreateEventHubConsumerGroupResponder handles the response to the CreateEventHubConsumerGroup request. The method always
   188  // closes the http.Response Body.
   189  func (client IotHubResourceClient) CreateEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) {
   190  	err = autorest.Respond(
   191  		resp,
   192  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   193  		autorest.ByUnmarshallingJSON(&result),
   194  		autorest.ByClosing())
   195  	result.Response = autorest.Response{Response: resp}
   196  	return
   197  }
   198  
   199  // CreateOrUpdate create or update the metadata of an Iot hub. The usual pattern to modify a property is to retrieve
   200  // the IoT hub metadata and security metadata, and then combine them with the modified values in a new body to update
   201  // the IoT hub.
   202  // Parameters:
   203  // resourceGroupName - the name of the resource group that contains the IoT hub.
   204  // resourceName - the name of the IoT hub.
   205  // iotHubDescription - the IoT hub metadata and security metadata.
   206  // ifMatch - eTag of the IoT Hub. Do not specify for creating a brand new IoT Hub. Required to update an
   207  // existing IoT Hub.
   208  func (client IotHubResourceClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription, ifMatch string) (result IotHubResourceCreateOrUpdateFuture, err error) {
   209  	if tracing.IsEnabled() {
   210  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateOrUpdate")
   211  		defer func() {
   212  			sc := -1
   213  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   214  				sc = result.FutureAPI.Response().StatusCode
   215  			}
   216  			tracing.EndSpan(ctx, sc, err)
   217  		}()
   218  	}
   219  	if err := validation.Validate([]validation.Validation{
   220  		{TargetValue: iotHubDescription,
   221  			Constraints: []validation.Constraint{{Target: "iotHubDescription.Properties", Name: validation.Null, Rule: false,
   222  				Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.NetworkRuleSets", Name: validation.Null, Rule: false,
   223  					Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.NetworkRuleSets.ApplyToBuiltInEventHubEndpoint", Name: validation.Null, Rule: true, Chain: nil},
   224  						{Target: "iotHubDescription.Properties.NetworkRuleSets.IPRules", Name: validation.Null, Rule: true, Chain: nil},
   225  					}},
   226  					{Target: "iotHubDescription.Properties.Routing", Name: validation.Null, Rule: false,
   227  						Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute", Name: validation.Null, Rule: false,
   228  							Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.Source", Name: validation.Null, Rule: true, Chain: nil},
   229  								{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.Null, Rule: true,
   230  									Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MaxItems, Rule: 1, Chain: nil},
   231  										{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MinItems, Rule: 1, Chain: nil},
   232  									}},
   233  								{Target: "iotHubDescription.Properties.Routing.FallbackRoute.IsEnabled", Name: validation.Null, Rule: true, Chain: nil},
   234  							}},
   235  						}},
   236  					{Target: "iotHubDescription.Properties.CloudToDevice", Name: validation.Null, Rule: false,
   237  						Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.Null, Rule: false,
   238  							Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
   239  								{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   240  							}},
   241  							{Target: "iotHubDescription.Properties.CloudToDevice.Feedback", Name: validation.Null, Rule: false,
   242  								Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.Null, Rule: false,
   243  									Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
   244  										{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   245  									}},
   246  								}},
   247  						}},
   248  				}},
   249  				{Target: "iotHubDescription.Sku", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   250  		return result, validation.NewError("devices.IotHubResourceClient", "CreateOrUpdate", err.Error())
   251  	}
   252  
   253  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, iotHubDescription, ifMatch)
   254  	if err != nil {
   255  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure preparing request")
   256  		return
   257  	}
   258  
   259  	result, err = client.CreateOrUpdateSender(req)
   260  	if err != nil {
   261  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   262  		return
   263  	}
   264  
   265  	return
   266  }
   267  
   268  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   269  func (client IotHubResourceClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription, ifMatch string) (*http.Request, error) {
   270  	pathParameters := map[string]interface{}{
   271  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   272  		"resourceName":      autorest.Encode("path", resourceName),
   273  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   274  	}
   275  
   276  	const APIVersion = "2021-03-03-preview"
   277  	queryParameters := map[string]interface{}{
   278  		"api-version": APIVersion,
   279  	}
   280  
   281  	preparer := autorest.CreatePreparer(
   282  		autorest.AsContentType("application/json; charset=utf-8"),
   283  		autorest.AsPut(),
   284  		autorest.WithBaseURL(client.BaseURI),
   285  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   286  		autorest.WithJSON(iotHubDescription),
   287  		autorest.WithQueryParameters(queryParameters))
   288  	if len(ifMatch) > 0 {
   289  		preparer = autorest.DecoratePreparer(preparer,
   290  			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   291  	}
   292  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   293  }
   294  
   295  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   296  // http.Response Body if it receives an error.
   297  func (client IotHubResourceClient) CreateOrUpdateSender(req *http.Request) (future IotHubResourceCreateOrUpdateFuture, err error) {
   298  	var resp *http.Response
   299  	future.FutureAPI = &azure.Future{}
   300  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   301  	if err != nil {
   302  		return
   303  	}
   304  	var azf azure.Future
   305  	azf, err = azure.NewFutureFromResponse(resp)
   306  	future.FutureAPI = &azf
   307  	future.Result = future.result
   308  	return
   309  }
   310  
   311  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   312  // closes the http.Response Body.
   313  func (client IotHubResourceClient) CreateOrUpdateResponder(resp *http.Response) (result IotHubDescription, err error) {
   314  	err = autorest.Respond(
   315  		resp,
   316  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   317  		autorest.ByUnmarshallingJSON(&result),
   318  		autorest.ByClosing())
   319  	result.Response = autorest.Response{Response: resp}
   320  	return
   321  }
   322  
   323  // Delete delete an IoT hub.
   324  // Parameters:
   325  // resourceGroupName - the name of the resource group that contains the IoT hub.
   326  // resourceName - the name of the IoT hub.
   327  func (client IotHubResourceClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubResourceDeleteFuture, err error) {
   328  	if tracing.IsEnabled() {
   329  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Delete")
   330  		defer func() {
   331  			sc := -1
   332  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   333  				sc = result.FutureAPI.Response().StatusCode
   334  			}
   335  			tracing.EndSpan(ctx, sc, err)
   336  		}()
   337  	}
   338  	req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName)
   339  	if err != nil {
   340  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure preparing request")
   341  		return
   342  	}
   343  
   344  	result, err = client.DeleteSender(req)
   345  	if err != nil {
   346  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", result.Response(), "Failure sending request")
   347  		return
   348  	}
   349  
   350  	return
   351  }
   352  
   353  // DeletePreparer prepares the Delete request.
   354  func (client IotHubResourceClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   355  	pathParameters := map[string]interface{}{
   356  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   357  		"resourceName":      autorest.Encode("path", resourceName),
   358  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   359  	}
   360  
   361  	const APIVersion = "2021-03-03-preview"
   362  	queryParameters := map[string]interface{}{
   363  		"api-version": APIVersion,
   364  	}
   365  
   366  	preparer := autorest.CreatePreparer(
   367  		autorest.AsDelete(),
   368  		autorest.WithBaseURL(client.BaseURI),
   369  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   370  		autorest.WithQueryParameters(queryParameters))
   371  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   372  }
   373  
   374  // DeleteSender sends the Delete request. The method will close the
   375  // http.Response Body if it receives an error.
   376  func (client IotHubResourceClient) DeleteSender(req *http.Request) (future IotHubResourceDeleteFuture, err error) {
   377  	var resp *http.Response
   378  	future.FutureAPI = &azure.Future{}
   379  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   380  	if err != nil {
   381  		return
   382  	}
   383  	var azf azure.Future
   384  	azf, err = azure.NewFutureFromResponse(resp)
   385  	future.FutureAPI = &azf
   386  	future.Result = future.result
   387  	return
   388  }
   389  
   390  // DeleteResponder handles the response to the Delete request. The method always
   391  // closes the http.Response Body.
   392  func (client IotHubResourceClient) DeleteResponder(resp *http.Response) (result SetObject, err error) {
   393  	err = autorest.Respond(
   394  		resp,
   395  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusNotFound),
   396  		autorest.ByUnmarshallingJSON(&result.Value),
   397  		autorest.ByClosing())
   398  	result.Response = autorest.Response{Response: resp}
   399  	return
   400  }
   401  
   402  // DeleteEventHubConsumerGroup delete a consumer group from an Event Hub-compatible endpoint in an IoT hub.
   403  // Parameters:
   404  // resourceGroupName - the name of the resource group that contains the IoT hub.
   405  // resourceName - the name of the IoT hub.
   406  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   407  // name - the name of the consumer group to delete.
   408  func (client IotHubResourceClient) DeleteEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result autorest.Response, err error) {
   409  	if tracing.IsEnabled() {
   410  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.DeleteEventHubConsumerGroup")
   411  		defer func() {
   412  			sc := -1
   413  			if result.Response != nil {
   414  				sc = result.Response.StatusCode
   415  			}
   416  			tracing.EndSpan(ctx, sc, err)
   417  		}()
   418  	}
   419  	req, err := client.DeleteEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name)
   420  	if err != nil {
   421  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", nil, "Failure preparing request")
   422  		return
   423  	}
   424  
   425  	resp, err := client.DeleteEventHubConsumerGroupSender(req)
   426  	if err != nil {
   427  		result.Response = resp
   428  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure sending request")
   429  		return
   430  	}
   431  
   432  	result, err = client.DeleteEventHubConsumerGroupResponder(resp)
   433  	if err != nil {
   434  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure responding to request")
   435  		return
   436  	}
   437  
   438  	return
   439  }
   440  
   441  // DeleteEventHubConsumerGroupPreparer prepares the DeleteEventHubConsumerGroup request.
   442  func (client IotHubResourceClient) DeleteEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) {
   443  	pathParameters := map[string]interface{}{
   444  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   445  		"name":                 autorest.Encode("path", name),
   446  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   447  		"resourceName":         autorest.Encode("path", resourceName),
   448  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   449  	}
   450  
   451  	const APIVersion = "2021-03-03-preview"
   452  	queryParameters := map[string]interface{}{
   453  		"api-version": APIVersion,
   454  	}
   455  
   456  	preparer := autorest.CreatePreparer(
   457  		autorest.AsDelete(),
   458  		autorest.WithBaseURL(client.BaseURI),
   459  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   460  		autorest.WithQueryParameters(queryParameters))
   461  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   462  }
   463  
   464  // DeleteEventHubConsumerGroupSender sends the DeleteEventHubConsumerGroup request. The method will close the
   465  // http.Response Body if it receives an error.
   466  func (client IotHubResourceClient) DeleteEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   467  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   468  }
   469  
   470  // DeleteEventHubConsumerGroupResponder handles the response to the DeleteEventHubConsumerGroup request. The method always
   471  // closes the http.Response Body.
   472  func (client IotHubResourceClient) DeleteEventHubConsumerGroupResponder(resp *http.Response) (result autorest.Response, err error) {
   473  	err = autorest.Respond(
   474  		resp,
   475  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   476  		autorest.ByClosing())
   477  	result.Response = resp
   478  	return
   479  }
   480  
   481  // ExportDevices exports all the device identities in the IoT hub identity registry to an Azure Storage blob container.
   482  // For more information, see:
   483  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.
   484  // Parameters:
   485  // resourceGroupName - the name of the resource group that contains the IoT hub.
   486  // resourceName - the name of the IoT hub.
   487  // exportDevicesParameters - the parameters that specify the export devices operation.
   488  func (client IotHubResourceClient) ExportDevices(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (result JobResponse, err error) {
   489  	if tracing.IsEnabled() {
   490  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ExportDevices")
   491  		defer func() {
   492  			sc := -1
   493  			if result.Response.Response != nil {
   494  				sc = result.Response.Response.StatusCode
   495  			}
   496  			tracing.EndSpan(ctx, sc, err)
   497  		}()
   498  	}
   499  	if err := validation.Validate([]validation.Validation{
   500  		{TargetValue: exportDevicesParameters,
   501  			Constraints: []validation.Constraint{{Target: "exportDevicesParameters.ExportBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil},
   502  				{Target: "exportDevicesParameters.ExcludeKeys", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   503  		return result, validation.NewError("devices.IotHubResourceClient", "ExportDevices", err.Error())
   504  	}
   505  
   506  	req, err := client.ExportDevicesPreparer(ctx, resourceGroupName, resourceName, exportDevicesParameters)
   507  	if err != nil {
   508  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", nil, "Failure preparing request")
   509  		return
   510  	}
   511  
   512  	resp, err := client.ExportDevicesSender(req)
   513  	if err != nil {
   514  		result.Response = autorest.Response{Response: resp}
   515  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure sending request")
   516  		return
   517  	}
   518  
   519  	result, err = client.ExportDevicesResponder(resp)
   520  	if err != nil {
   521  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure responding to request")
   522  		return
   523  	}
   524  
   525  	return
   526  }
   527  
   528  // ExportDevicesPreparer prepares the ExportDevices request.
   529  func (client IotHubResourceClient) ExportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (*http.Request, error) {
   530  	pathParameters := map[string]interface{}{
   531  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   532  		"resourceName":      autorest.Encode("path", resourceName),
   533  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   534  	}
   535  
   536  	const APIVersion = "2021-03-03-preview"
   537  	queryParameters := map[string]interface{}{
   538  		"api-version": APIVersion,
   539  	}
   540  
   541  	preparer := autorest.CreatePreparer(
   542  		autorest.AsContentType("application/json; charset=utf-8"),
   543  		autorest.AsPost(),
   544  		autorest.WithBaseURL(client.BaseURI),
   545  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/exportDevices", pathParameters),
   546  		autorest.WithJSON(exportDevicesParameters),
   547  		autorest.WithQueryParameters(queryParameters))
   548  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   549  }
   550  
   551  // ExportDevicesSender sends the ExportDevices request. The method will close the
   552  // http.Response Body if it receives an error.
   553  func (client IotHubResourceClient) ExportDevicesSender(req *http.Request) (*http.Response, error) {
   554  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   555  }
   556  
   557  // ExportDevicesResponder handles the response to the ExportDevices request. The method always
   558  // closes the http.Response Body.
   559  func (client IotHubResourceClient) ExportDevicesResponder(resp *http.Response) (result JobResponse, err error) {
   560  	err = autorest.Respond(
   561  		resp,
   562  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   563  		autorest.ByUnmarshallingJSON(&result),
   564  		autorest.ByClosing())
   565  	result.Response = autorest.Response{Response: resp}
   566  	return
   567  }
   568  
   569  // Get get the non-security related metadata of an IoT hub.
   570  // Parameters:
   571  // resourceGroupName - the name of the resource group that contains the IoT hub.
   572  // resourceName - the name of the IoT hub.
   573  func (client IotHubResourceClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubDescription, err error) {
   574  	if tracing.IsEnabled() {
   575  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Get")
   576  		defer func() {
   577  			sc := -1
   578  			if result.Response.Response != nil {
   579  				sc = result.Response.Response.StatusCode
   580  			}
   581  			tracing.EndSpan(ctx, sc, err)
   582  		}()
   583  	}
   584  	req, err := client.GetPreparer(ctx, resourceGroupName, resourceName)
   585  	if err != nil {
   586  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", nil, "Failure preparing request")
   587  		return
   588  	}
   589  
   590  	resp, err := client.GetSender(req)
   591  	if err != nil {
   592  		result.Response = autorest.Response{Response: resp}
   593  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure sending request")
   594  		return
   595  	}
   596  
   597  	result, err = client.GetResponder(resp)
   598  	if err != nil {
   599  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure responding to request")
   600  		return
   601  	}
   602  
   603  	return
   604  }
   605  
   606  // GetPreparer prepares the Get request.
   607  func (client IotHubResourceClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   608  	pathParameters := map[string]interface{}{
   609  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   610  		"resourceName":      autorest.Encode("path", resourceName),
   611  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   612  	}
   613  
   614  	const APIVersion = "2021-03-03-preview"
   615  	queryParameters := map[string]interface{}{
   616  		"api-version": APIVersion,
   617  	}
   618  
   619  	preparer := autorest.CreatePreparer(
   620  		autorest.AsGet(),
   621  		autorest.WithBaseURL(client.BaseURI),
   622  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   623  		autorest.WithQueryParameters(queryParameters))
   624  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   625  }
   626  
   627  // GetSender sends the Get request. The method will close the
   628  // http.Response Body if it receives an error.
   629  func (client IotHubResourceClient) GetSender(req *http.Request) (*http.Response, error) {
   630  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   631  }
   632  
   633  // GetResponder handles the response to the Get request. The method always
   634  // closes the http.Response Body.
   635  func (client IotHubResourceClient) GetResponder(resp *http.Response) (result IotHubDescription, err error) {
   636  	err = autorest.Respond(
   637  		resp,
   638  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   639  		autorest.ByUnmarshallingJSON(&result),
   640  		autorest.ByClosing())
   641  	result.Response = autorest.Response{Response: resp}
   642  	return
   643  }
   644  
   645  // GetEndpointHealth get the health for routing endpoints.
   646  func (client IotHubResourceClient) GetEndpointHealth(ctx context.Context, resourceGroupName string, iotHubName string) (result EndpointHealthDataListResultPage, err error) {
   647  	if tracing.IsEnabled() {
   648  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEndpointHealth")
   649  		defer func() {
   650  			sc := -1
   651  			if result.ehdlr.Response.Response != nil {
   652  				sc = result.ehdlr.Response.Response.StatusCode
   653  			}
   654  			tracing.EndSpan(ctx, sc, err)
   655  		}()
   656  	}
   657  	result.fn = client.getEndpointHealthNextResults
   658  	req, err := client.GetEndpointHealthPreparer(ctx, resourceGroupName, iotHubName)
   659  	if err != nil {
   660  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", nil, "Failure preparing request")
   661  		return
   662  	}
   663  
   664  	resp, err := client.GetEndpointHealthSender(req)
   665  	if err != nil {
   666  		result.ehdlr.Response = autorest.Response{Response: resp}
   667  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", resp, "Failure sending request")
   668  		return
   669  	}
   670  
   671  	result.ehdlr, err = client.GetEndpointHealthResponder(resp)
   672  	if err != nil {
   673  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEndpointHealth", resp, "Failure responding to request")
   674  		return
   675  	}
   676  	if result.ehdlr.hasNextLink() && result.ehdlr.IsEmpty() {
   677  		err = result.NextWithContext(ctx)
   678  		return
   679  	}
   680  
   681  	return
   682  }
   683  
   684  // GetEndpointHealthPreparer prepares the GetEndpointHealth request.
   685  func (client IotHubResourceClient) GetEndpointHealthPreparer(ctx context.Context, resourceGroupName string, iotHubName string) (*http.Request, error) {
   686  	pathParameters := map[string]interface{}{
   687  		"iotHubName":        autorest.Encode("path", iotHubName),
   688  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   689  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   690  	}
   691  
   692  	const APIVersion = "2021-03-03-preview"
   693  	queryParameters := map[string]interface{}{
   694  		"api-version": APIVersion,
   695  	}
   696  
   697  	preparer := autorest.CreatePreparer(
   698  		autorest.AsGet(),
   699  		autorest.WithBaseURL(client.BaseURI),
   700  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{iotHubName}/routingEndpointsHealth", pathParameters),
   701  		autorest.WithQueryParameters(queryParameters))
   702  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   703  }
   704  
   705  // GetEndpointHealthSender sends the GetEndpointHealth request. The method will close the
   706  // http.Response Body if it receives an error.
   707  func (client IotHubResourceClient) GetEndpointHealthSender(req *http.Request) (*http.Response, error) {
   708  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   709  }
   710  
   711  // GetEndpointHealthResponder handles the response to the GetEndpointHealth request. The method always
   712  // closes the http.Response Body.
   713  func (client IotHubResourceClient) GetEndpointHealthResponder(resp *http.Response) (result EndpointHealthDataListResult, err error) {
   714  	err = autorest.Respond(
   715  		resp,
   716  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   717  		autorest.ByUnmarshallingJSON(&result),
   718  		autorest.ByClosing())
   719  	result.Response = autorest.Response{Response: resp}
   720  	return
   721  }
   722  
   723  // getEndpointHealthNextResults retrieves the next set of results, if any.
   724  func (client IotHubResourceClient) getEndpointHealthNextResults(ctx context.Context, lastResults EndpointHealthDataListResult) (result EndpointHealthDataListResult, err error) {
   725  	req, err := lastResults.endpointHealthDataListResultPreparer(ctx)
   726  	if err != nil {
   727  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", nil, "Failure preparing next results request")
   728  	}
   729  	if req == nil {
   730  		return
   731  	}
   732  	resp, err := client.GetEndpointHealthSender(req)
   733  	if err != nil {
   734  		result.Response = autorest.Response{Response: resp}
   735  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", resp, "Failure sending next results request")
   736  	}
   737  	result, err = client.GetEndpointHealthResponder(resp)
   738  	if err != nil {
   739  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getEndpointHealthNextResults", resp, "Failure responding to next results request")
   740  	}
   741  	return
   742  }
   743  
   744  // GetEndpointHealthComplete enumerates all values, automatically crossing page boundaries as required.
   745  func (client IotHubResourceClient) GetEndpointHealthComplete(ctx context.Context, resourceGroupName string, iotHubName string) (result EndpointHealthDataListResultIterator, err error) {
   746  	if tracing.IsEnabled() {
   747  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEndpointHealth")
   748  		defer func() {
   749  			sc := -1
   750  			if result.Response().Response.Response != nil {
   751  				sc = result.page.Response().Response.Response.StatusCode
   752  			}
   753  			tracing.EndSpan(ctx, sc, err)
   754  		}()
   755  	}
   756  	result.page, err = client.GetEndpointHealth(ctx, resourceGroupName, iotHubName)
   757  	return
   758  }
   759  
   760  // GetEventHubConsumerGroup get a consumer group from the Event Hub-compatible device-to-cloud endpoint for an IoT hub.
   761  // Parameters:
   762  // resourceGroupName - the name of the resource group that contains the IoT hub.
   763  // resourceName - the name of the IoT hub.
   764  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   765  // name - the name of the consumer group to retrieve.
   766  func (client IotHubResourceClient) GetEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) {
   767  	if tracing.IsEnabled() {
   768  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEventHubConsumerGroup")
   769  		defer func() {
   770  			sc := -1
   771  			if result.Response.Response != nil {
   772  				sc = result.Response.Response.StatusCode
   773  			}
   774  			tracing.EndSpan(ctx, sc, err)
   775  		}()
   776  	}
   777  	req, err := client.GetEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name)
   778  	if err != nil {
   779  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", nil, "Failure preparing request")
   780  		return
   781  	}
   782  
   783  	resp, err := client.GetEventHubConsumerGroupSender(req)
   784  	if err != nil {
   785  		result.Response = autorest.Response{Response: resp}
   786  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure sending request")
   787  		return
   788  	}
   789  
   790  	result, err = client.GetEventHubConsumerGroupResponder(resp)
   791  	if err != nil {
   792  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure responding to request")
   793  		return
   794  	}
   795  
   796  	return
   797  }
   798  
   799  // GetEventHubConsumerGroupPreparer prepares the GetEventHubConsumerGroup request.
   800  func (client IotHubResourceClient) GetEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) {
   801  	pathParameters := map[string]interface{}{
   802  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   803  		"name":                 autorest.Encode("path", name),
   804  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   805  		"resourceName":         autorest.Encode("path", resourceName),
   806  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   807  	}
   808  
   809  	const APIVersion = "2021-03-03-preview"
   810  	queryParameters := map[string]interface{}{
   811  		"api-version": APIVersion,
   812  	}
   813  
   814  	preparer := autorest.CreatePreparer(
   815  		autorest.AsGet(),
   816  		autorest.WithBaseURL(client.BaseURI),
   817  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   818  		autorest.WithQueryParameters(queryParameters))
   819  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   820  }
   821  
   822  // GetEventHubConsumerGroupSender sends the GetEventHubConsumerGroup request. The method will close the
   823  // http.Response Body if it receives an error.
   824  func (client IotHubResourceClient) GetEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   825  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   826  }
   827  
   828  // GetEventHubConsumerGroupResponder handles the response to the GetEventHubConsumerGroup request. The method always
   829  // closes the http.Response Body.
   830  func (client IotHubResourceClient) GetEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) {
   831  	err = autorest.Respond(
   832  		resp,
   833  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   834  		autorest.ByUnmarshallingJSON(&result),
   835  		autorest.ByClosing())
   836  	result.Response = autorest.Response{Response: resp}
   837  	return
   838  }
   839  
   840  // GetJob get the details of a job from an IoT hub. For more information, see:
   841  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry.
   842  // Parameters:
   843  // resourceGroupName - the name of the resource group that contains the IoT hub.
   844  // resourceName - the name of the IoT hub.
   845  // jobID - the job identifier.
   846  func (client IotHubResourceClient) GetJob(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (result JobResponse, err error) {
   847  	if tracing.IsEnabled() {
   848  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetJob")
   849  		defer func() {
   850  			sc := -1
   851  			if result.Response.Response != nil {
   852  				sc = result.Response.Response.StatusCode
   853  			}
   854  			tracing.EndSpan(ctx, sc, err)
   855  		}()
   856  	}
   857  	req, err := client.GetJobPreparer(ctx, resourceGroupName, resourceName, jobID)
   858  	if err != nil {
   859  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", nil, "Failure preparing request")
   860  		return
   861  	}
   862  
   863  	resp, err := client.GetJobSender(req)
   864  	if err != nil {
   865  		result.Response = autorest.Response{Response: resp}
   866  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure sending request")
   867  		return
   868  	}
   869  
   870  	result, err = client.GetJobResponder(resp)
   871  	if err != nil {
   872  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure responding to request")
   873  		return
   874  	}
   875  
   876  	return
   877  }
   878  
   879  // GetJobPreparer prepares the GetJob request.
   880  func (client IotHubResourceClient) GetJobPreparer(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (*http.Request, error) {
   881  	pathParameters := map[string]interface{}{
   882  		"jobId":             autorest.Encode("path", jobID),
   883  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   884  		"resourceName":      autorest.Encode("path", resourceName),
   885  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   886  	}
   887  
   888  	const APIVersion = "2021-03-03-preview"
   889  	queryParameters := map[string]interface{}{
   890  		"api-version": APIVersion,
   891  	}
   892  
   893  	preparer := autorest.CreatePreparer(
   894  		autorest.AsGet(),
   895  		autorest.WithBaseURL(client.BaseURI),
   896  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs/{jobId}", pathParameters),
   897  		autorest.WithQueryParameters(queryParameters))
   898  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   899  }
   900  
   901  // GetJobSender sends the GetJob request. The method will close the
   902  // http.Response Body if it receives an error.
   903  func (client IotHubResourceClient) GetJobSender(req *http.Request) (*http.Response, error) {
   904  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   905  }
   906  
   907  // GetJobResponder handles the response to the GetJob request. The method always
   908  // closes the http.Response Body.
   909  func (client IotHubResourceClient) GetJobResponder(resp *http.Response) (result JobResponse, err error) {
   910  	err = autorest.Respond(
   911  		resp,
   912  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   913  		autorest.ByUnmarshallingJSON(&result),
   914  		autorest.ByClosing())
   915  	result.Response = autorest.Response{Response: resp}
   916  	return
   917  }
   918  
   919  // GetKeysForKeyName get a shared access policy by name from an IoT hub. For more information, see:
   920  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security.
   921  // Parameters:
   922  // resourceGroupName - the name of the resource group that contains the IoT hub.
   923  // resourceName - the name of the IoT hub.
   924  // keyName - the name of the shared access policy.
   925  func (client IotHubResourceClient) GetKeysForKeyName(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (result SharedAccessSignatureAuthorizationRule, err error) {
   926  	if tracing.IsEnabled() {
   927  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetKeysForKeyName")
   928  		defer func() {
   929  			sc := -1
   930  			if result.Response.Response != nil {
   931  				sc = result.Response.Response.StatusCode
   932  			}
   933  			tracing.EndSpan(ctx, sc, err)
   934  		}()
   935  	}
   936  	req, err := client.GetKeysForKeyNamePreparer(ctx, resourceGroupName, resourceName, keyName)
   937  	if err != nil {
   938  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", nil, "Failure preparing request")
   939  		return
   940  	}
   941  
   942  	resp, err := client.GetKeysForKeyNameSender(req)
   943  	if err != nil {
   944  		result.Response = autorest.Response{Response: resp}
   945  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure sending request")
   946  		return
   947  	}
   948  
   949  	result, err = client.GetKeysForKeyNameResponder(resp)
   950  	if err != nil {
   951  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure responding to request")
   952  		return
   953  	}
   954  
   955  	return
   956  }
   957  
   958  // GetKeysForKeyNamePreparer prepares the GetKeysForKeyName request.
   959  func (client IotHubResourceClient) GetKeysForKeyNamePreparer(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (*http.Request, error) {
   960  	pathParameters := map[string]interface{}{
   961  		"keyName":           autorest.Encode("path", keyName),
   962  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   963  		"resourceName":      autorest.Encode("path", resourceName),
   964  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   965  	}
   966  
   967  	const APIVersion = "2021-03-03-preview"
   968  	queryParameters := map[string]interface{}{
   969  		"api-version": APIVersion,
   970  	}
   971  
   972  	preparer := autorest.CreatePreparer(
   973  		autorest.AsPost(),
   974  		autorest.WithBaseURL(client.BaseURI),
   975  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubKeys/{keyName}/listkeys", pathParameters),
   976  		autorest.WithQueryParameters(queryParameters))
   977  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   978  }
   979  
   980  // GetKeysForKeyNameSender sends the GetKeysForKeyName request. The method will close the
   981  // http.Response Body if it receives an error.
   982  func (client IotHubResourceClient) GetKeysForKeyNameSender(req *http.Request) (*http.Response, error) {
   983  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   984  }
   985  
   986  // GetKeysForKeyNameResponder handles the response to the GetKeysForKeyName request. The method always
   987  // closes the http.Response Body.
   988  func (client IotHubResourceClient) GetKeysForKeyNameResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRule, err error) {
   989  	err = autorest.Respond(
   990  		resp,
   991  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   992  		autorest.ByUnmarshallingJSON(&result),
   993  		autorest.ByClosing())
   994  	result.Response = autorest.Response{Response: resp}
   995  	return
   996  }
   997  
   998  // GetQuotaMetrics get the quota metrics for an IoT hub.
   999  // Parameters:
  1000  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1001  // resourceName - the name of the IoT hub.
  1002  func (client IotHubResourceClient) GetQuotaMetrics(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultPage, err error) {
  1003  	if tracing.IsEnabled() {
  1004  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics")
  1005  		defer func() {
  1006  			sc := -1
  1007  			if result.ihqmilr.Response.Response != nil {
  1008  				sc = result.ihqmilr.Response.Response.StatusCode
  1009  			}
  1010  			tracing.EndSpan(ctx, sc, err)
  1011  		}()
  1012  	}
  1013  	result.fn = client.getQuotaMetricsNextResults
  1014  	req, err := client.GetQuotaMetricsPreparer(ctx, resourceGroupName, resourceName)
  1015  	if err != nil {
  1016  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", nil, "Failure preparing request")
  1017  		return
  1018  	}
  1019  
  1020  	resp, err := client.GetQuotaMetricsSender(req)
  1021  	if err != nil {
  1022  		result.ihqmilr.Response = autorest.Response{Response: resp}
  1023  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure sending request")
  1024  		return
  1025  	}
  1026  
  1027  	result.ihqmilr, err = client.GetQuotaMetricsResponder(resp)
  1028  	if err != nil {
  1029  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure responding to request")
  1030  		return
  1031  	}
  1032  	if result.ihqmilr.hasNextLink() && result.ihqmilr.IsEmpty() {
  1033  		err = result.NextWithContext(ctx)
  1034  		return
  1035  	}
  1036  
  1037  	return
  1038  }
  1039  
  1040  // GetQuotaMetricsPreparer prepares the GetQuotaMetrics request.
  1041  func (client IotHubResourceClient) GetQuotaMetricsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1042  	pathParameters := map[string]interface{}{
  1043  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1044  		"resourceName":      autorest.Encode("path", resourceName),
  1045  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1046  	}
  1047  
  1048  	const APIVersion = "2021-03-03-preview"
  1049  	queryParameters := map[string]interface{}{
  1050  		"api-version": APIVersion,
  1051  	}
  1052  
  1053  	preparer := autorest.CreatePreparer(
  1054  		autorest.AsGet(),
  1055  		autorest.WithBaseURL(client.BaseURI),
  1056  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/quotaMetrics", pathParameters),
  1057  		autorest.WithQueryParameters(queryParameters))
  1058  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1059  }
  1060  
  1061  // GetQuotaMetricsSender sends the GetQuotaMetrics request. The method will close the
  1062  // http.Response Body if it receives an error.
  1063  func (client IotHubResourceClient) GetQuotaMetricsSender(req *http.Request) (*http.Response, error) {
  1064  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1065  }
  1066  
  1067  // GetQuotaMetricsResponder handles the response to the GetQuotaMetrics request. The method always
  1068  // closes the http.Response Body.
  1069  func (client IotHubResourceClient) GetQuotaMetricsResponder(resp *http.Response) (result IotHubQuotaMetricInfoListResult, err error) {
  1070  	err = autorest.Respond(
  1071  		resp,
  1072  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1073  		autorest.ByUnmarshallingJSON(&result),
  1074  		autorest.ByClosing())
  1075  	result.Response = autorest.Response{Response: resp}
  1076  	return
  1077  }
  1078  
  1079  // getQuotaMetricsNextResults retrieves the next set of results, if any.
  1080  func (client IotHubResourceClient) getQuotaMetricsNextResults(ctx context.Context, lastResults IotHubQuotaMetricInfoListResult) (result IotHubQuotaMetricInfoListResult, err error) {
  1081  	req, err := lastResults.iotHubQuotaMetricInfoListResultPreparer(ctx)
  1082  	if err != nil {
  1083  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", nil, "Failure preparing next results request")
  1084  	}
  1085  	if req == nil {
  1086  		return
  1087  	}
  1088  	resp, err := client.GetQuotaMetricsSender(req)
  1089  	if err != nil {
  1090  		result.Response = autorest.Response{Response: resp}
  1091  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure sending next results request")
  1092  	}
  1093  	result, err = client.GetQuotaMetricsResponder(resp)
  1094  	if err != nil {
  1095  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure responding to next results request")
  1096  	}
  1097  	return
  1098  }
  1099  
  1100  // GetQuotaMetricsComplete enumerates all values, automatically crossing page boundaries as required.
  1101  func (client IotHubResourceClient) GetQuotaMetricsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultIterator, err error) {
  1102  	if tracing.IsEnabled() {
  1103  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics")
  1104  		defer func() {
  1105  			sc := -1
  1106  			if result.Response().Response.Response != nil {
  1107  				sc = result.page.Response().Response.Response.StatusCode
  1108  			}
  1109  			tracing.EndSpan(ctx, sc, err)
  1110  		}()
  1111  	}
  1112  	result.page, err = client.GetQuotaMetrics(ctx, resourceGroupName, resourceName)
  1113  	return
  1114  }
  1115  
  1116  // GetStats get the statistics from an IoT hub.
  1117  // Parameters:
  1118  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1119  // resourceName - the name of the IoT hub.
  1120  func (client IotHubResourceClient) GetStats(ctx context.Context, resourceGroupName string, resourceName string) (result RegistryStatistics, err error) {
  1121  	if tracing.IsEnabled() {
  1122  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetStats")
  1123  		defer func() {
  1124  			sc := -1
  1125  			if result.Response.Response != nil {
  1126  				sc = result.Response.Response.StatusCode
  1127  			}
  1128  			tracing.EndSpan(ctx, sc, err)
  1129  		}()
  1130  	}
  1131  	req, err := client.GetStatsPreparer(ctx, resourceGroupName, resourceName)
  1132  	if err != nil {
  1133  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", nil, "Failure preparing request")
  1134  		return
  1135  	}
  1136  
  1137  	resp, err := client.GetStatsSender(req)
  1138  	if err != nil {
  1139  		result.Response = autorest.Response{Response: resp}
  1140  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure sending request")
  1141  		return
  1142  	}
  1143  
  1144  	result, err = client.GetStatsResponder(resp)
  1145  	if err != nil {
  1146  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure responding to request")
  1147  		return
  1148  	}
  1149  
  1150  	return
  1151  }
  1152  
  1153  // GetStatsPreparer prepares the GetStats request.
  1154  func (client IotHubResourceClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1155  	pathParameters := map[string]interface{}{
  1156  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1157  		"resourceName":      autorest.Encode("path", resourceName),
  1158  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1159  	}
  1160  
  1161  	const APIVersion = "2021-03-03-preview"
  1162  	queryParameters := map[string]interface{}{
  1163  		"api-version": APIVersion,
  1164  	}
  1165  
  1166  	preparer := autorest.CreatePreparer(
  1167  		autorest.AsGet(),
  1168  		autorest.WithBaseURL(client.BaseURI),
  1169  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubStats", pathParameters),
  1170  		autorest.WithQueryParameters(queryParameters))
  1171  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1172  }
  1173  
  1174  // GetStatsSender sends the GetStats request. The method will close the
  1175  // http.Response Body if it receives an error.
  1176  func (client IotHubResourceClient) GetStatsSender(req *http.Request) (*http.Response, error) {
  1177  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1178  }
  1179  
  1180  // GetStatsResponder handles the response to the GetStats request. The method always
  1181  // closes the http.Response Body.
  1182  func (client IotHubResourceClient) GetStatsResponder(resp *http.Response) (result RegistryStatistics, err error) {
  1183  	err = autorest.Respond(
  1184  		resp,
  1185  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1186  		autorest.ByUnmarshallingJSON(&result),
  1187  		autorest.ByClosing())
  1188  	result.Response = autorest.Response{Response: resp}
  1189  	return
  1190  }
  1191  
  1192  // GetValidSkus get the list of valid SKUs for an IoT hub.
  1193  // Parameters:
  1194  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1195  // resourceName - the name of the IoT hub.
  1196  func (client IotHubResourceClient) GetValidSkus(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultPage, err error) {
  1197  	if tracing.IsEnabled() {
  1198  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus")
  1199  		defer func() {
  1200  			sc := -1
  1201  			if result.ihsdlr.Response.Response != nil {
  1202  				sc = result.ihsdlr.Response.Response.StatusCode
  1203  			}
  1204  			tracing.EndSpan(ctx, sc, err)
  1205  		}()
  1206  	}
  1207  	result.fn = client.getValidSkusNextResults
  1208  	req, err := client.GetValidSkusPreparer(ctx, resourceGroupName, resourceName)
  1209  	if err != nil {
  1210  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", nil, "Failure preparing request")
  1211  		return
  1212  	}
  1213  
  1214  	resp, err := client.GetValidSkusSender(req)
  1215  	if err != nil {
  1216  		result.ihsdlr.Response = autorest.Response{Response: resp}
  1217  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure sending request")
  1218  		return
  1219  	}
  1220  
  1221  	result.ihsdlr, err = client.GetValidSkusResponder(resp)
  1222  	if err != nil {
  1223  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure responding to request")
  1224  		return
  1225  	}
  1226  	if result.ihsdlr.hasNextLink() && result.ihsdlr.IsEmpty() {
  1227  		err = result.NextWithContext(ctx)
  1228  		return
  1229  	}
  1230  
  1231  	return
  1232  }
  1233  
  1234  // GetValidSkusPreparer prepares the GetValidSkus request.
  1235  func (client IotHubResourceClient) GetValidSkusPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1236  	pathParameters := map[string]interface{}{
  1237  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1238  		"resourceName":      autorest.Encode("path", resourceName),
  1239  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1240  	}
  1241  
  1242  	const APIVersion = "2021-03-03-preview"
  1243  	queryParameters := map[string]interface{}{
  1244  		"api-version": APIVersion,
  1245  	}
  1246  
  1247  	preparer := autorest.CreatePreparer(
  1248  		autorest.AsGet(),
  1249  		autorest.WithBaseURL(client.BaseURI),
  1250  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/skus", pathParameters),
  1251  		autorest.WithQueryParameters(queryParameters))
  1252  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1253  }
  1254  
  1255  // GetValidSkusSender sends the GetValidSkus request. The method will close the
  1256  // http.Response Body if it receives an error.
  1257  func (client IotHubResourceClient) GetValidSkusSender(req *http.Request) (*http.Response, error) {
  1258  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1259  }
  1260  
  1261  // GetValidSkusResponder handles the response to the GetValidSkus request. The method always
  1262  // closes the http.Response Body.
  1263  func (client IotHubResourceClient) GetValidSkusResponder(resp *http.Response) (result IotHubSkuDescriptionListResult, err error) {
  1264  	err = autorest.Respond(
  1265  		resp,
  1266  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1267  		autorest.ByUnmarshallingJSON(&result),
  1268  		autorest.ByClosing())
  1269  	result.Response = autorest.Response{Response: resp}
  1270  	return
  1271  }
  1272  
  1273  // getValidSkusNextResults retrieves the next set of results, if any.
  1274  func (client IotHubResourceClient) getValidSkusNextResults(ctx context.Context, lastResults IotHubSkuDescriptionListResult) (result IotHubSkuDescriptionListResult, err error) {
  1275  	req, err := lastResults.iotHubSkuDescriptionListResultPreparer(ctx)
  1276  	if err != nil {
  1277  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", nil, "Failure preparing next results request")
  1278  	}
  1279  	if req == nil {
  1280  		return
  1281  	}
  1282  	resp, err := client.GetValidSkusSender(req)
  1283  	if err != nil {
  1284  		result.Response = autorest.Response{Response: resp}
  1285  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure sending next results request")
  1286  	}
  1287  	result, err = client.GetValidSkusResponder(resp)
  1288  	if err != nil {
  1289  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure responding to next results request")
  1290  	}
  1291  	return
  1292  }
  1293  
  1294  // GetValidSkusComplete enumerates all values, automatically crossing page boundaries as required.
  1295  func (client IotHubResourceClient) GetValidSkusComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultIterator, err error) {
  1296  	if tracing.IsEnabled() {
  1297  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus")
  1298  		defer func() {
  1299  			sc := -1
  1300  			if result.Response().Response.Response != nil {
  1301  				sc = result.page.Response().Response.Response.StatusCode
  1302  			}
  1303  			tracing.EndSpan(ctx, sc, err)
  1304  		}()
  1305  	}
  1306  	result.page, err = client.GetValidSkus(ctx, resourceGroupName, resourceName)
  1307  	return
  1308  }
  1309  
  1310  // ImportDevices import, update, or delete device identities in the IoT hub identity registry from a blob. For more
  1311  // information, see:
  1312  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.
  1313  // Parameters:
  1314  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1315  // resourceName - the name of the IoT hub.
  1316  // importDevicesParameters - the parameters that specify the import devices operation.
  1317  func (client IotHubResourceClient) ImportDevices(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (result JobResponse, err error) {
  1318  	if tracing.IsEnabled() {
  1319  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ImportDevices")
  1320  		defer func() {
  1321  			sc := -1
  1322  			if result.Response.Response != nil {
  1323  				sc = result.Response.Response.StatusCode
  1324  			}
  1325  			tracing.EndSpan(ctx, sc, err)
  1326  		}()
  1327  	}
  1328  	if err := validation.Validate([]validation.Validation{
  1329  		{TargetValue: importDevicesParameters,
  1330  			Constraints: []validation.Constraint{{Target: "importDevicesParameters.InputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil},
  1331  				{Target: "importDevicesParameters.OutputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1332  		return result, validation.NewError("devices.IotHubResourceClient", "ImportDevices", err.Error())
  1333  	}
  1334  
  1335  	req, err := client.ImportDevicesPreparer(ctx, resourceGroupName, resourceName, importDevicesParameters)
  1336  	if err != nil {
  1337  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", nil, "Failure preparing request")
  1338  		return
  1339  	}
  1340  
  1341  	resp, err := client.ImportDevicesSender(req)
  1342  	if err != nil {
  1343  		result.Response = autorest.Response{Response: resp}
  1344  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure sending request")
  1345  		return
  1346  	}
  1347  
  1348  	result, err = client.ImportDevicesResponder(resp)
  1349  	if err != nil {
  1350  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure responding to request")
  1351  		return
  1352  	}
  1353  
  1354  	return
  1355  }
  1356  
  1357  // ImportDevicesPreparer prepares the ImportDevices request.
  1358  func (client IotHubResourceClient) ImportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (*http.Request, error) {
  1359  	pathParameters := map[string]interface{}{
  1360  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1361  		"resourceName":      autorest.Encode("path", resourceName),
  1362  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1363  	}
  1364  
  1365  	const APIVersion = "2021-03-03-preview"
  1366  	queryParameters := map[string]interface{}{
  1367  		"api-version": APIVersion,
  1368  	}
  1369  
  1370  	preparer := autorest.CreatePreparer(
  1371  		autorest.AsContentType("application/json; charset=utf-8"),
  1372  		autorest.AsPost(),
  1373  		autorest.WithBaseURL(client.BaseURI),
  1374  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/importDevices", pathParameters),
  1375  		autorest.WithJSON(importDevicesParameters),
  1376  		autorest.WithQueryParameters(queryParameters))
  1377  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1378  }
  1379  
  1380  // ImportDevicesSender sends the ImportDevices request. The method will close the
  1381  // http.Response Body if it receives an error.
  1382  func (client IotHubResourceClient) ImportDevicesSender(req *http.Request) (*http.Response, error) {
  1383  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1384  }
  1385  
  1386  // ImportDevicesResponder handles the response to the ImportDevices request. The method always
  1387  // closes the http.Response Body.
  1388  func (client IotHubResourceClient) ImportDevicesResponder(resp *http.Response) (result JobResponse, err error) {
  1389  	err = autorest.Respond(
  1390  		resp,
  1391  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1392  		autorest.ByUnmarshallingJSON(&result),
  1393  		autorest.ByClosing())
  1394  	result.Response = autorest.Response{Response: resp}
  1395  	return
  1396  }
  1397  
  1398  // ListByResourceGroup get all the IoT hubs in a resource group.
  1399  // Parameters:
  1400  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1401  func (client IotHubResourceClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultPage, err error) {
  1402  	if tracing.IsEnabled() {
  1403  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup")
  1404  		defer func() {
  1405  			sc := -1
  1406  			if result.ihdlr.Response.Response != nil {
  1407  				sc = result.ihdlr.Response.Response.StatusCode
  1408  			}
  1409  			tracing.EndSpan(ctx, sc, err)
  1410  		}()
  1411  	}
  1412  	result.fn = client.listByResourceGroupNextResults
  1413  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
  1414  	if err != nil {
  1415  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", nil, "Failure preparing request")
  1416  		return
  1417  	}
  1418  
  1419  	resp, err := client.ListByResourceGroupSender(req)
  1420  	if err != nil {
  1421  		result.ihdlr.Response = autorest.Response{Response: resp}
  1422  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure sending request")
  1423  		return
  1424  	}
  1425  
  1426  	result.ihdlr, err = client.ListByResourceGroupResponder(resp)
  1427  	if err != nil {
  1428  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure responding to request")
  1429  		return
  1430  	}
  1431  	if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() {
  1432  		err = result.NextWithContext(ctx)
  1433  		return
  1434  	}
  1435  
  1436  	return
  1437  }
  1438  
  1439  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
  1440  func (client IotHubResourceClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
  1441  	pathParameters := map[string]interface{}{
  1442  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1443  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1444  	}
  1445  
  1446  	const APIVersion = "2021-03-03-preview"
  1447  	queryParameters := map[string]interface{}{
  1448  		"api-version": APIVersion,
  1449  	}
  1450  
  1451  	preparer := autorest.CreatePreparer(
  1452  		autorest.AsGet(),
  1453  		autorest.WithBaseURL(client.BaseURI),
  1454  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs", pathParameters),
  1455  		autorest.WithQueryParameters(queryParameters))
  1456  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1457  }
  1458  
  1459  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
  1460  // http.Response Body if it receives an error.
  1461  func (client IotHubResourceClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
  1462  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1463  }
  1464  
  1465  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
  1466  // closes the http.Response Body.
  1467  func (client IotHubResourceClient) ListByResourceGroupResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) {
  1468  	err = autorest.Respond(
  1469  		resp,
  1470  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1471  		autorest.ByUnmarshallingJSON(&result),
  1472  		autorest.ByClosing())
  1473  	result.Response = autorest.Response{Response: resp}
  1474  	return
  1475  }
  1476  
  1477  // listByResourceGroupNextResults retrieves the next set of results, if any.
  1478  func (client IotHubResourceClient) listByResourceGroupNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) {
  1479  	req, err := lastResults.iotHubDescriptionListResultPreparer(ctx)
  1480  	if err != nil {
  1481  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
  1482  	}
  1483  	if req == nil {
  1484  		return
  1485  	}
  1486  	resp, err := client.ListByResourceGroupSender(req)
  1487  	if err != nil {
  1488  		result.Response = autorest.Response{Response: resp}
  1489  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
  1490  	}
  1491  	result, err = client.ListByResourceGroupResponder(resp)
  1492  	if err != nil {
  1493  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
  1494  	}
  1495  	return
  1496  }
  1497  
  1498  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
  1499  func (client IotHubResourceClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultIterator, err error) {
  1500  	if tracing.IsEnabled() {
  1501  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup")
  1502  		defer func() {
  1503  			sc := -1
  1504  			if result.Response().Response.Response != nil {
  1505  				sc = result.page.Response().Response.Response.StatusCode
  1506  			}
  1507  			tracing.EndSpan(ctx, sc, err)
  1508  		}()
  1509  	}
  1510  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
  1511  	return
  1512  }
  1513  
  1514  // ListBySubscription get all the IoT hubs in a subscription.
  1515  func (client IotHubResourceClient) ListBySubscription(ctx context.Context) (result IotHubDescriptionListResultPage, err error) {
  1516  	if tracing.IsEnabled() {
  1517  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription")
  1518  		defer func() {
  1519  			sc := -1
  1520  			if result.ihdlr.Response.Response != nil {
  1521  				sc = result.ihdlr.Response.Response.StatusCode
  1522  			}
  1523  			tracing.EndSpan(ctx, sc, err)
  1524  		}()
  1525  	}
  1526  	result.fn = client.listBySubscriptionNextResults
  1527  	req, err := client.ListBySubscriptionPreparer(ctx)
  1528  	if err != nil {
  1529  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", nil, "Failure preparing request")
  1530  		return
  1531  	}
  1532  
  1533  	resp, err := client.ListBySubscriptionSender(req)
  1534  	if err != nil {
  1535  		result.ihdlr.Response = autorest.Response{Response: resp}
  1536  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure sending request")
  1537  		return
  1538  	}
  1539  
  1540  	result.ihdlr, err = client.ListBySubscriptionResponder(resp)
  1541  	if err != nil {
  1542  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure responding to request")
  1543  		return
  1544  	}
  1545  	if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() {
  1546  		err = result.NextWithContext(ctx)
  1547  		return
  1548  	}
  1549  
  1550  	return
  1551  }
  1552  
  1553  // ListBySubscriptionPreparer prepares the ListBySubscription request.
  1554  func (client IotHubResourceClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
  1555  	pathParameters := map[string]interface{}{
  1556  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
  1557  	}
  1558  
  1559  	const APIVersion = "2021-03-03-preview"
  1560  	queryParameters := map[string]interface{}{
  1561  		"api-version": APIVersion,
  1562  	}
  1563  
  1564  	preparer := autorest.CreatePreparer(
  1565  		autorest.AsGet(),
  1566  		autorest.WithBaseURL(client.BaseURI),
  1567  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/IotHubs", pathParameters),
  1568  		autorest.WithQueryParameters(queryParameters))
  1569  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1570  }
  1571  
  1572  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
  1573  // http.Response Body if it receives an error.
  1574  func (client IotHubResourceClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
  1575  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1576  }
  1577  
  1578  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
  1579  // closes the http.Response Body.
  1580  func (client IotHubResourceClient) ListBySubscriptionResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) {
  1581  	err = autorest.Respond(
  1582  		resp,
  1583  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1584  		autorest.ByUnmarshallingJSON(&result),
  1585  		autorest.ByClosing())
  1586  	result.Response = autorest.Response{Response: resp}
  1587  	return
  1588  }
  1589  
  1590  // listBySubscriptionNextResults retrieves the next set of results, if any.
  1591  func (client IotHubResourceClient) listBySubscriptionNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) {
  1592  	req, err := lastResults.iotHubDescriptionListResultPreparer(ctx)
  1593  	if err != nil {
  1594  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
  1595  	}
  1596  	if req == nil {
  1597  		return
  1598  	}
  1599  	resp, err := client.ListBySubscriptionSender(req)
  1600  	if err != nil {
  1601  		result.Response = autorest.Response{Response: resp}
  1602  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
  1603  	}
  1604  	result, err = client.ListBySubscriptionResponder(resp)
  1605  	if err != nil {
  1606  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
  1607  	}
  1608  	return
  1609  }
  1610  
  1611  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
  1612  func (client IotHubResourceClient) ListBySubscriptionComplete(ctx context.Context) (result IotHubDescriptionListResultIterator, err error) {
  1613  	if tracing.IsEnabled() {
  1614  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription")
  1615  		defer func() {
  1616  			sc := -1
  1617  			if result.Response().Response.Response != nil {
  1618  				sc = result.page.Response().Response.Response.StatusCode
  1619  			}
  1620  			tracing.EndSpan(ctx, sc, err)
  1621  		}()
  1622  	}
  1623  	result.page, err = client.ListBySubscription(ctx)
  1624  	return
  1625  }
  1626  
  1627  // ListEventHubConsumerGroups get a list of the consumer groups in the Event Hub-compatible device-to-cloud endpoint in
  1628  // an IoT hub.
  1629  // Parameters:
  1630  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1631  // resourceName - the name of the IoT hub.
  1632  // eventHubEndpointName - the name of the Event Hub-compatible endpoint.
  1633  func (client IotHubResourceClient) ListEventHubConsumerGroups(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultPage, err error) {
  1634  	if tracing.IsEnabled() {
  1635  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups")
  1636  		defer func() {
  1637  			sc := -1
  1638  			if result.ehcglr.Response.Response != nil {
  1639  				sc = result.ehcglr.Response.Response.StatusCode
  1640  			}
  1641  			tracing.EndSpan(ctx, sc, err)
  1642  		}()
  1643  	}
  1644  	result.fn = client.listEventHubConsumerGroupsNextResults
  1645  	req, err := client.ListEventHubConsumerGroupsPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName)
  1646  	if err != nil {
  1647  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", nil, "Failure preparing request")
  1648  		return
  1649  	}
  1650  
  1651  	resp, err := client.ListEventHubConsumerGroupsSender(req)
  1652  	if err != nil {
  1653  		result.ehcglr.Response = autorest.Response{Response: resp}
  1654  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure sending request")
  1655  		return
  1656  	}
  1657  
  1658  	result.ehcglr, err = client.ListEventHubConsumerGroupsResponder(resp)
  1659  	if err != nil {
  1660  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure responding to request")
  1661  		return
  1662  	}
  1663  	if result.ehcglr.hasNextLink() && result.ehcglr.IsEmpty() {
  1664  		err = result.NextWithContext(ctx)
  1665  		return
  1666  	}
  1667  
  1668  	return
  1669  }
  1670  
  1671  // ListEventHubConsumerGroupsPreparer prepares the ListEventHubConsumerGroups request.
  1672  func (client IotHubResourceClient) ListEventHubConsumerGroupsPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (*http.Request, error) {
  1673  	pathParameters := map[string]interface{}{
  1674  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
  1675  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
  1676  		"resourceName":         autorest.Encode("path", resourceName),
  1677  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
  1678  	}
  1679  
  1680  	const APIVersion = "2021-03-03-preview"
  1681  	queryParameters := map[string]interface{}{
  1682  		"api-version": APIVersion,
  1683  	}
  1684  
  1685  	preparer := autorest.CreatePreparer(
  1686  		autorest.AsGet(),
  1687  		autorest.WithBaseURL(client.BaseURI),
  1688  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups", pathParameters),
  1689  		autorest.WithQueryParameters(queryParameters))
  1690  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1691  }
  1692  
  1693  // ListEventHubConsumerGroupsSender sends the ListEventHubConsumerGroups request. The method will close the
  1694  // http.Response Body if it receives an error.
  1695  func (client IotHubResourceClient) ListEventHubConsumerGroupsSender(req *http.Request) (*http.Response, error) {
  1696  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1697  }
  1698  
  1699  // ListEventHubConsumerGroupsResponder handles the response to the ListEventHubConsumerGroups request. The method always
  1700  // closes the http.Response Body.
  1701  func (client IotHubResourceClient) ListEventHubConsumerGroupsResponder(resp *http.Response) (result EventHubConsumerGroupsListResult, err error) {
  1702  	err = autorest.Respond(
  1703  		resp,
  1704  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1705  		autorest.ByUnmarshallingJSON(&result),
  1706  		autorest.ByClosing())
  1707  	result.Response = autorest.Response{Response: resp}
  1708  	return
  1709  }
  1710  
  1711  // listEventHubConsumerGroupsNextResults retrieves the next set of results, if any.
  1712  func (client IotHubResourceClient) listEventHubConsumerGroupsNextResults(ctx context.Context, lastResults EventHubConsumerGroupsListResult) (result EventHubConsumerGroupsListResult, err error) {
  1713  	req, err := lastResults.eventHubConsumerGroupsListResultPreparer(ctx)
  1714  	if err != nil {
  1715  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", nil, "Failure preparing next results request")
  1716  	}
  1717  	if req == nil {
  1718  		return
  1719  	}
  1720  	resp, err := client.ListEventHubConsumerGroupsSender(req)
  1721  	if err != nil {
  1722  		result.Response = autorest.Response{Response: resp}
  1723  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure sending next results request")
  1724  	}
  1725  	result, err = client.ListEventHubConsumerGroupsResponder(resp)
  1726  	if err != nil {
  1727  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure responding to next results request")
  1728  	}
  1729  	return
  1730  }
  1731  
  1732  // ListEventHubConsumerGroupsComplete enumerates all values, automatically crossing page boundaries as required.
  1733  func (client IotHubResourceClient) ListEventHubConsumerGroupsComplete(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultIterator, err error) {
  1734  	if tracing.IsEnabled() {
  1735  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups")
  1736  		defer func() {
  1737  			sc := -1
  1738  			if result.Response().Response.Response != nil {
  1739  				sc = result.page.Response().Response.Response.StatusCode
  1740  			}
  1741  			tracing.EndSpan(ctx, sc, err)
  1742  		}()
  1743  	}
  1744  	result.page, err = client.ListEventHubConsumerGroups(ctx, resourceGroupName, resourceName, eventHubEndpointName)
  1745  	return
  1746  }
  1747  
  1748  // ListJobs get a list of all the jobs in an IoT hub. For more information, see:
  1749  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry.
  1750  // Parameters:
  1751  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1752  // resourceName - the name of the IoT hub.
  1753  func (client IotHubResourceClient) ListJobs(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultPage, err error) {
  1754  	if tracing.IsEnabled() {
  1755  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs")
  1756  		defer func() {
  1757  			sc := -1
  1758  			if result.jrlr.Response.Response != nil {
  1759  				sc = result.jrlr.Response.Response.StatusCode
  1760  			}
  1761  			tracing.EndSpan(ctx, sc, err)
  1762  		}()
  1763  	}
  1764  	result.fn = client.listJobsNextResults
  1765  	req, err := client.ListJobsPreparer(ctx, resourceGroupName, resourceName)
  1766  	if err != nil {
  1767  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", nil, "Failure preparing request")
  1768  		return
  1769  	}
  1770  
  1771  	resp, err := client.ListJobsSender(req)
  1772  	if err != nil {
  1773  		result.jrlr.Response = autorest.Response{Response: resp}
  1774  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure sending request")
  1775  		return
  1776  	}
  1777  
  1778  	result.jrlr, err = client.ListJobsResponder(resp)
  1779  	if err != nil {
  1780  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure responding to request")
  1781  		return
  1782  	}
  1783  	if result.jrlr.hasNextLink() && result.jrlr.IsEmpty() {
  1784  		err = result.NextWithContext(ctx)
  1785  		return
  1786  	}
  1787  
  1788  	return
  1789  }
  1790  
  1791  // ListJobsPreparer prepares the ListJobs request.
  1792  func (client IotHubResourceClient) ListJobsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1793  	pathParameters := map[string]interface{}{
  1794  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1795  		"resourceName":      autorest.Encode("path", resourceName),
  1796  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1797  	}
  1798  
  1799  	const APIVersion = "2021-03-03-preview"
  1800  	queryParameters := map[string]interface{}{
  1801  		"api-version": APIVersion,
  1802  	}
  1803  
  1804  	preparer := autorest.CreatePreparer(
  1805  		autorest.AsGet(),
  1806  		autorest.WithBaseURL(client.BaseURI),
  1807  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs", pathParameters),
  1808  		autorest.WithQueryParameters(queryParameters))
  1809  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1810  }
  1811  
  1812  // ListJobsSender sends the ListJobs request. The method will close the
  1813  // http.Response Body if it receives an error.
  1814  func (client IotHubResourceClient) ListJobsSender(req *http.Request) (*http.Response, error) {
  1815  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1816  }
  1817  
  1818  // ListJobsResponder handles the response to the ListJobs request. The method always
  1819  // closes the http.Response Body.
  1820  func (client IotHubResourceClient) ListJobsResponder(resp *http.Response) (result JobResponseListResult, err error) {
  1821  	err = autorest.Respond(
  1822  		resp,
  1823  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1824  		autorest.ByUnmarshallingJSON(&result),
  1825  		autorest.ByClosing())
  1826  	result.Response = autorest.Response{Response: resp}
  1827  	return
  1828  }
  1829  
  1830  // listJobsNextResults retrieves the next set of results, if any.
  1831  func (client IotHubResourceClient) listJobsNextResults(ctx context.Context, lastResults JobResponseListResult) (result JobResponseListResult, err error) {
  1832  	req, err := lastResults.jobResponseListResultPreparer(ctx)
  1833  	if err != nil {
  1834  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", nil, "Failure preparing next results request")
  1835  	}
  1836  	if req == nil {
  1837  		return
  1838  	}
  1839  	resp, err := client.ListJobsSender(req)
  1840  	if err != nil {
  1841  		result.Response = autorest.Response{Response: resp}
  1842  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure sending next results request")
  1843  	}
  1844  	result, err = client.ListJobsResponder(resp)
  1845  	if err != nil {
  1846  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure responding to next results request")
  1847  	}
  1848  	return
  1849  }
  1850  
  1851  // ListJobsComplete enumerates all values, automatically crossing page boundaries as required.
  1852  func (client IotHubResourceClient) ListJobsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultIterator, err error) {
  1853  	if tracing.IsEnabled() {
  1854  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs")
  1855  		defer func() {
  1856  			sc := -1
  1857  			if result.Response().Response.Response != nil {
  1858  				sc = result.page.Response().Response.Response.StatusCode
  1859  			}
  1860  			tracing.EndSpan(ctx, sc, err)
  1861  		}()
  1862  	}
  1863  	result.page, err = client.ListJobs(ctx, resourceGroupName, resourceName)
  1864  	return
  1865  }
  1866  
  1867  // ListKeys get the security metadata for an IoT hub. For more information, see:
  1868  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security.
  1869  // Parameters:
  1870  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1871  // resourceName - the name of the IoT hub.
  1872  func (client IotHubResourceClient) ListKeys(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultPage, err error) {
  1873  	if tracing.IsEnabled() {
  1874  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys")
  1875  		defer func() {
  1876  			sc := -1
  1877  			if result.sasarlr.Response.Response != nil {
  1878  				sc = result.sasarlr.Response.Response.StatusCode
  1879  			}
  1880  			tracing.EndSpan(ctx, sc, err)
  1881  		}()
  1882  	}
  1883  	result.fn = client.listKeysNextResults
  1884  	req, err := client.ListKeysPreparer(ctx, resourceGroupName, resourceName)
  1885  	if err != nil {
  1886  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", nil, "Failure preparing request")
  1887  		return
  1888  	}
  1889  
  1890  	resp, err := client.ListKeysSender(req)
  1891  	if err != nil {
  1892  		result.sasarlr.Response = autorest.Response{Response: resp}
  1893  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure sending request")
  1894  		return
  1895  	}
  1896  
  1897  	result.sasarlr, err = client.ListKeysResponder(resp)
  1898  	if err != nil {
  1899  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure responding to request")
  1900  		return
  1901  	}
  1902  	if result.sasarlr.hasNextLink() && result.sasarlr.IsEmpty() {
  1903  		err = result.NextWithContext(ctx)
  1904  		return
  1905  	}
  1906  
  1907  	return
  1908  }
  1909  
  1910  // ListKeysPreparer prepares the ListKeys request.
  1911  func (client IotHubResourceClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1912  	pathParameters := map[string]interface{}{
  1913  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1914  		"resourceName":      autorest.Encode("path", resourceName),
  1915  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1916  	}
  1917  
  1918  	const APIVersion = "2021-03-03-preview"
  1919  	queryParameters := map[string]interface{}{
  1920  		"api-version": APIVersion,
  1921  	}
  1922  
  1923  	preparer := autorest.CreatePreparer(
  1924  		autorest.AsPost(),
  1925  		autorest.WithBaseURL(client.BaseURI),
  1926  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/listkeys", pathParameters),
  1927  		autorest.WithQueryParameters(queryParameters))
  1928  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1929  }
  1930  
  1931  // ListKeysSender sends the ListKeys request. The method will close the
  1932  // http.Response Body if it receives an error.
  1933  func (client IotHubResourceClient) ListKeysSender(req *http.Request) (*http.Response, error) {
  1934  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1935  }
  1936  
  1937  // ListKeysResponder handles the response to the ListKeys request. The method always
  1938  // closes the http.Response Body.
  1939  func (client IotHubResourceClient) ListKeysResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1940  	err = autorest.Respond(
  1941  		resp,
  1942  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1943  		autorest.ByUnmarshallingJSON(&result),
  1944  		autorest.ByClosing())
  1945  	result.Response = autorest.Response{Response: resp}
  1946  	return
  1947  }
  1948  
  1949  // listKeysNextResults retrieves the next set of results, if any.
  1950  func (client IotHubResourceClient) listKeysNextResults(ctx context.Context, lastResults SharedAccessSignatureAuthorizationRuleListResult) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1951  	req, err := lastResults.sharedAccessSignatureAuthorizationRuleListResultPreparer(ctx)
  1952  	if err != nil {
  1953  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", nil, "Failure preparing next results request")
  1954  	}
  1955  	if req == nil {
  1956  		return
  1957  	}
  1958  	resp, err := client.ListKeysSender(req)
  1959  	if err != nil {
  1960  		result.Response = autorest.Response{Response: resp}
  1961  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure sending next results request")
  1962  	}
  1963  	result, err = client.ListKeysResponder(resp)
  1964  	if err != nil {
  1965  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure responding to next results request")
  1966  	}
  1967  	return
  1968  }
  1969  
  1970  // ListKeysComplete enumerates all values, automatically crossing page boundaries as required.
  1971  func (client IotHubResourceClient) ListKeysComplete(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultIterator, err error) {
  1972  	if tracing.IsEnabled() {
  1973  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys")
  1974  		defer func() {
  1975  			sc := -1
  1976  			if result.Response().Response.Response != nil {
  1977  				sc = result.page.Response().Response.Response.StatusCode
  1978  			}
  1979  			tracing.EndSpan(ctx, sc, err)
  1980  		}()
  1981  	}
  1982  	result.page, err = client.ListKeys(ctx, resourceGroupName, resourceName)
  1983  	return
  1984  }
  1985  
  1986  // TestAllRoutes test all routes configured in this Iot Hub
  1987  // Parameters:
  1988  // input - input for testing all routes
  1989  // iotHubName - iotHub to be tested
  1990  // resourceGroupName - resource group which Iot Hub belongs to
  1991  func (client IotHubResourceClient) TestAllRoutes(ctx context.Context, input TestAllRoutesInput, iotHubName string, resourceGroupName string) (result TestAllRoutesResult, err error) {
  1992  	if tracing.IsEnabled() {
  1993  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.TestAllRoutes")
  1994  		defer func() {
  1995  			sc := -1
  1996  			if result.Response.Response != nil {
  1997  				sc = result.Response.Response.StatusCode
  1998  			}
  1999  			tracing.EndSpan(ctx, sc, err)
  2000  		}()
  2001  	}
  2002  	req, err := client.TestAllRoutesPreparer(ctx, input, iotHubName, resourceGroupName)
  2003  	if err != nil {
  2004  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", nil, "Failure preparing request")
  2005  		return
  2006  	}
  2007  
  2008  	resp, err := client.TestAllRoutesSender(req)
  2009  	if err != nil {
  2010  		result.Response = autorest.Response{Response: resp}
  2011  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", resp, "Failure sending request")
  2012  		return
  2013  	}
  2014  
  2015  	result, err = client.TestAllRoutesResponder(resp)
  2016  	if err != nil {
  2017  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestAllRoutes", resp, "Failure responding to request")
  2018  		return
  2019  	}
  2020  
  2021  	return
  2022  }
  2023  
  2024  // TestAllRoutesPreparer prepares the TestAllRoutes request.
  2025  func (client IotHubResourceClient) TestAllRoutesPreparer(ctx context.Context, input TestAllRoutesInput, iotHubName string, resourceGroupName string) (*http.Request, error) {
  2026  	pathParameters := map[string]interface{}{
  2027  		"iotHubName":        autorest.Encode("path", iotHubName),
  2028  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2029  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2030  	}
  2031  
  2032  	const APIVersion = "2021-03-03-preview"
  2033  	queryParameters := map[string]interface{}{
  2034  		"api-version": APIVersion,
  2035  	}
  2036  
  2037  	preparer := autorest.CreatePreparer(
  2038  		autorest.AsContentType("application/json; charset=utf-8"),
  2039  		autorest.AsPost(),
  2040  		autorest.WithBaseURL(client.BaseURI),
  2041  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{iotHubName}/routing/routes/$testall", pathParameters),
  2042  		autorest.WithJSON(input),
  2043  		autorest.WithQueryParameters(queryParameters))
  2044  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2045  }
  2046  
  2047  // TestAllRoutesSender sends the TestAllRoutes request. The method will close the
  2048  // http.Response Body if it receives an error.
  2049  func (client IotHubResourceClient) TestAllRoutesSender(req *http.Request) (*http.Response, error) {
  2050  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2051  }
  2052  
  2053  // TestAllRoutesResponder handles the response to the TestAllRoutes request. The method always
  2054  // closes the http.Response Body.
  2055  func (client IotHubResourceClient) TestAllRoutesResponder(resp *http.Response) (result TestAllRoutesResult, err error) {
  2056  	err = autorest.Respond(
  2057  		resp,
  2058  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2059  		autorest.ByUnmarshallingJSON(&result),
  2060  		autorest.ByClosing())
  2061  	result.Response = autorest.Response{Response: resp}
  2062  	return
  2063  }
  2064  
  2065  // TestRoute test the new route for this Iot Hub
  2066  // Parameters:
  2067  // input - route that needs to be tested
  2068  // iotHubName - iotHub to be tested
  2069  // resourceGroupName - resource group which Iot Hub belongs to
  2070  func (client IotHubResourceClient) TestRoute(ctx context.Context, input TestRouteInput, iotHubName string, resourceGroupName string) (result TestRouteResult, err error) {
  2071  	if tracing.IsEnabled() {
  2072  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.TestRoute")
  2073  		defer func() {
  2074  			sc := -1
  2075  			if result.Response.Response != nil {
  2076  				sc = result.Response.Response.StatusCode
  2077  			}
  2078  			tracing.EndSpan(ctx, sc, err)
  2079  		}()
  2080  	}
  2081  	if err := validation.Validate([]validation.Validation{
  2082  		{TargetValue: input,
  2083  			Constraints: []validation.Constraint{{Target: "input.Route", Name: validation.Null, Rule: true,
  2084  				Chain: []validation.Constraint{{Target: "input.Route.Name", Name: validation.Null, Rule: true,
  2085  					Chain: []validation.Constraint{{Target: "input.Route.Name", Name: validation.Pattern, Rule: `^[A-Za-z0-9-._]{1,64}$`, Chain: nil}}},
  2086  					{Target: "input.Route.EndpointNames", Name: validation.Null, Rule: true,
  2087  						Chain: []validation.Constraint{{Target: "input.Route.EndpointNames", Name: validation.MaxItems, Rule: 1, Chain: nil},
  2088  							{Target: "input.Route.EndpointNames", Name: validation.MinItems, Rule: 1, Chain: nil},
  2089  						}},
  2090  					{Target: "input.Route.IsEnabled", Name: validation.Null, Rule: true, Chain: nil},
  2091  				}}}}}); err != nil {
  2092  		return result, validation.NewError("devices.IotHubResourceClient", "TestRoute", err.Error())
  2093  	}
  2094  
  2095  	req, err := client.TestRoutePreparer(ctx, input, iotHubName, resourceGroupName)
  2096  	if err != nil {
  2097  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", nil, "Failure preparing request")
  2098  		return
  2099  	}
  2100  
  2101  	resp, err := client.TestRouteSender(req)
  2102  	if err != nil {
  2103  		result.Response = autorest.Response{Response: resp}
  2104  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", resp, "Failure sending request")
  2105  		return
  2106  	}
  2107  
  2108  	result, err = client.TestRouteResponder(resp)
  2109  	if err != nil {
  2110  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "TestRoute", resp, "Failure responding to request")
  2111  		return
  2112  	}
  2113  
  2114  	return
  2115  }
  2116  
  2117  // TestRoutePreparer prepares the TestRoute request.
  2118  func (client IotHubResourceClient) TestRoutePreparer(ctx context.Context, input TestRouteInput, iotHubName string, resourceGroupName string) (*http.Request, error) {
  2119  	pathParameters := map[string]interface{}{
  2120  		"iotHubName":        autorest.Encode("path", iotHubName),
  2121  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2122  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2123  	}
  2124  
  2125  	const APIVersion = "2021-03-03-preview"
  2126  	queryParameters := map[string]interface{}{
  2127  		"api-version": APIVersion,
  2128  	}
  2129  
  2130  	preparer := autorest.CreatePreparer(
  2131  		autorest.AsContentType("application/json; charset=utf-8"),
  2132  		autorest.AsPost(),
  2133  		autorest.WithBaseURL(client.BaseURI),
  2134  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{iotHubName}/routing/routes/$testnew", pathParameters),
  2135  		autorest.WithJSON(input),
  2136  		autorest.WithQueryParameters(queryParameters))
  2137  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2138  }
  2139  
  2140  // TestRouteSender sends the TestRoute request. The method will close the
  2141  // http.Response Body if it receives an error.
  2142  func (client IotHubResourceClient) TestRouteSender(req *http.Request) (*http.Response, error) {
  2143  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2144  }
  2145  
  2146  // TestRouteResponder handles the response to the TestRoute request. The method always
  2147  // closes the http.Response Body.
  2148  func (client IotHubResourceClient) TestRouteResponder(resp *http.Response) (result TestRouteResult, err error) {
  2149  	err = autorest.Respond(
  2150  		resp,
  2151  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2152  		autorest.ByUnmarshallingJSON(&result),
  2153  		autorest.ByClosing())
  2154  	result.Response = autorest.Response{Response: resp}
  2155  	return
  2156  }
  2157  
  2158  // Update update an existing IoT Hub tags. to update other fields use the CreateOrUpdate method
  2159  // Parameters:
  2160  // resourceGroupName - resource group identifier.
  2161  // resourceName - name of iot hub to update.
  2162  // iotHubTags - updated tag information to set into the iot hub instance.
  2163  func (client IotHubResourceClient) Update(ctx context.Context, resourceGroupName string, resourceName string, iotHubTags TagsResource) (result IotHubResourceUpdateFuture, err error) {
  2164  	if tracing.IsEnabled() {
  2165  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Update")
  2166  		defer func() {
  2167  			sc := -1
  2168  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  2169  				sc = result.FutureAPI.Response().StatusCode
  2170  			}
  2171  			tracing.EndSpan(ctx, sc, err)
  2172  		}()
  2173  	}
  2174  	req, err := client.UpdatePreparer(ctx, resourceGroupName, resourceName, iotHubTags)
  2175  	if err != nil {
  2176  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Update", nil, "Failure preparing request")
  2177  		return
  2178  	}
  2179  
  2180  	result, err = client.UpdateSender(req)
  2181  	if err != nil {
  2182  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Update", result.Response(), "Failure sending request")
  2183  		return
  2184  	}
  2185  
  2186  	return
  2187  }
  2188  
  2189  // UpdatePreparer prepares the Update request.
  2190  func (client IotHubResourceClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubTags TagsResource) (*http.Request, error) {
  2191  	pathParameters := map[string]interface{}{
  2192  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2193  		"resourceName":      autorest.Encode("path", resourceName),
  2194  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2195  	}
  2196  
  2197  	const APIVersion = "2021-03-03-preview"
  2198  	queryParameters := map[string]interface{}{
  2199  		"api-version": APIVersion,
  2200  	}
  2201  
  2202  	preparer := autorest.CreatePreparer(
  2203  		autorest.AsContentType("application/json; charset=utf-8"),
  2204  		autorest.AsPatch(),
  2205  		autorest.WithBaseURL(client.BaseURI),
  2206  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
  2207  		autorest.WithJSON(iotHubTags),
  2208  		autorest.WithQueryParameters(queryParameters))
  2209  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2210  }
  2211  
  2212  // UpdateSender sends the Update request. The method will close the
  2213  // http.Response Body if it receives an error.
  2214  func (client IotHubResourceClient) UpdateSender(req *http.Request) (future IotHubResourceUpdateFuture, err error) {
  2215  	var resp *http.Response
  2216  	future.FutureAPI = &azure.Future{}
  2217  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2218  	if err != nil {
  2219  		return
  2220  	}
  2221  	var azf azure.Future
  2222  	azf, err = azure.NewFutureFromResponse(resp)
  2223  	future.FutureAPI = &azf
  2224  	future.Result = future.result
  2225  	return
  2226  }
  2227  
  2228  // UpdateResponder handles the response to the Update request. The method always
  2229  // closes the http.Response Body.
  2230  func (client IotHubResourceClient) UpdateResponder(resp *http.Response) (result IotHubDescription, err error) {
  2231  	err = autorest.Respond(
  2232  		resp,
  2233  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2234  		autorest.ByUnmarshallingJSON(&result),
  2235  		autorest.ByClosing())
  2236  	result.Response = autorest.Response{Response: resp}
  2237  	return
  2238  }
  2239  

View as plain text