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

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

View as plain text