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

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

View as plain text