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

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

View as plain text