Source file src/github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2015-04-08/documentdb/databaseaccounts.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2015-04-08/documentdb

     1  package documentdb
     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  // DatabaseAccountsClient is the azure Cosmos DB Database Service Resource Provider REST API
    19  type DatabaseAccountsClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewDatabaseAccountsClient creates an instance of the DatabaseAccountsClient client.
    24  func NewDatabaseAccountsClient(subscriptionID string) DatabaseAccountsClient {
    25  	return NewDatabaseAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewDatabaseAccountsClientWithBaseURI creates an instance of the DatabaseAccountsClient client using a custom
    29  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    30  // stack).
    31  func NewDatabaseAccountsClientWithBaseURI(baseURI string, subscriptionID string) DatabaseAccountsClient {
    32  	return DatabaseAccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CheckNameExists checks that the Azure Cosmos DB account name already exists. A valid account name may contain only
    36  // lowercase letters, numbers, and the '-' character, and must be between 3 and 50 characters.
    37  // Parameters:
    38  // accountName - cosmos DB database account name.
    39  func (client DatabaseAccountsClient) CheckNameExists(ctx context.Context, accountName string) (result autorest.Response, err error) {
    40  	if tracing.IsEnabled() {
    41  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CheckNameExists")
    42  		defer func() {
    43  			sc := -1
    44  			if result.Response != nil {
    45  				sc = result.Response.StatusCode
    46  			}
    47  			tracing.EndSpan(ctx, sc, err)
    48  		}()
    49  	}
    50  	if err := validation.Validate([]validation.Validation{
    51  		{TargetValue: accountName,
    52  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
    53  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
    54  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
    55  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CheckNameExists", err.Error())
    56  	}
    57  
    58  	req, err := client.CheckNameExistsPreparer(ctx, accountName)
    59  	if err != nil {
    60  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CheckNameExists", nil, "Failure preparing request")
    61  		return
    62  	}
    63  
    64  	resp, err := client.CheckNameExistsSender(req)
    65  	if err != nil {
    66  		result.Response = resp
    67  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CheckNameExists", resp, "Failure sending request")
    68  		return
    69  	}
    70  
    71  	result, err = client.CheckNameExistsResponder(resp)
    72  	if err != nil {
    73  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CheckNameExists", resp, "Failure responding to request")
    74  		return
    75  	}
    76  
    77  	return
    78  }
    79  
    80  // CheckNameExistsPreparer prepares the CheckNameExists request.
    81  func (client DatabaseAccountsClient) CheckNameExistsPreparer(ctx context.Context, accountName string) (*http.Request, error) {
    82  	pathParameters := map[string]interface{}{
    83  		"accountName": autorest.Encode("path", accountName),
    84  	}
    85  
    86  	const APIVersion = "2015-04-08"
    87  	queryParameters := map[string]interface{}{
    88  		"api-version": APIVersion,
    89  	}
    90  
    91  	preparer := autorest.CreatePreparer(
    92  		autorest.AsHead(),
    93  		autorest.WithBaseURL(client.BaseURI),
    94  		autorest.WithPathParameters("/providers/Microsoft.DocumentDB/databaseAccountNames/{accountName}", pathParameters),
    95  		autorest.WithQueryParameters(queryParameters))
    96  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    97  }
    98  
    99  // CheckNameExistsSender sends the CheckNameExists request. The method will close the
   100  // http.Response Body if it receives an error.
   101  func (client DatabaseAccountsClient) CheckNameExistsSender(req *http.Request) (*http.Response, error) {
   102  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   103  }
   104  
   105  // CheckNameExistsResponder handles the response to the CheckNameExists request. The method always
   106  // closes the http.Response Body.
   107  func (client DatabaseAccountsClient) CheckNameExistsResponder(resp *http.Response) (result autorest.Response, err error) {
   108  	err = autorest.Respond(
   109  		resp,
   110  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
   111  		autorest.ByClosing())
   112  	result.Response = resp
   113  	return
   114  }
   115  
   116  // CreateOrUpdate creates or updates an Azure Cosmos DB database account.
   117  // Parameters:
   118  // resourceGroupName - name of an Azure resource group.
   119  // accountName - cosmos DB database account name.
   120  // createUpdateParameters - the parameters to provide for the current database account.
   121  func (client DatabaseAccountsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, createUpdateParameters DatabaseAccountCreateUpdateParameters) (result DatabaseAccountsCreateOrUpdateFuture, err error) {
   122  	if tracing.IsEnabled() {
   123  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateOrUpdate")
   124  		defer func() {
   125  			sc := -1
   126  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   127  				sc = result.FutureAPI.Response().StatusCode
   128  			}
   129  			tracing.EndSpan(ctx, sc, err)
   130  		}()
   131  	}
   132  	if err := validation.Validate([]validation.Validation{
   133  		{TargetValue: resourceGroupName,
   134  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   135  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   136  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   137  		{TargetValue: accountName,
   138  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   139  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   140  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   141  		{TargetValue: createUpdateParameters,
   142  			Constraints: []validation.Constraint{{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties", Name: validation.Null, Rule: true,
   143  				Chain: []validation.Constraint{{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy", Name: validation.Null, Rule: false,
   144  					Chain: []validation.Constraint{{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxStalenessPrefix", Name: validation.Null, Rule: false,
   145  						Chain: []validation.Constraint{{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxStalenessPrefix", Name: validation.InclusiveMaximum, Rule: int64(2147483647), Chain: nil},
   146  							{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxStalenessPrefix", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   147  						}},
   148  						{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxIntervalInSeconds", Name: validation.Null, Rule: false,
   149  							Chain: []validation.Constraint{{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxIntervalInSeconds", Name: validation.InclusiveMaximum, Rule: int64(86400), Chain: nil},
   150  								{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.ConsistencyPolicy.MaxIntervalInSeconds", Name: validation.InclusiveMinimum, Rule: int64(5), Chain: nil},
   151  							}},
   152  					}},
   153  					{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.Locations", Name: validation.Null, Rule: true, Chain: nil},
   154  					{Target: "createUpdateParameters.DatabaseAccountCreateUpdateProperties.DatabaseAccountOfferType", Name: validation.Null, Rule: true, Chain: nil},
   155  				}}}}}); err != nil {
   156  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateOrUpdate", err.Error())
   157  	}
   158  
   159  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, createUpdateParameters)
   160  	if err != nil {
   161  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateOrUpdate", nil, "Failure preparing request")
   162  		return
   163  	}
   164  
   165  	result, err = client.CreateOrUpdateSender(req)
   166  	if err != nil {
   167  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   168  		return
   169  	}
   170  
   171  	return
   172  }
   173  
   174  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   175  func (client DatabaseAccountsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, createUpdateParameters DatabaseAccountCreateUpdateParameters) (*http.Request, error) {
   176  	pathParameters := map[string]interface{}{
   177  		"accountName":       autorest.Encode("path", accountName),
   178  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   179  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   180  	}
   181  
   182  	const APIVersion = "2015-04-08"
   183  	queryParameters := map[string]interface{}{
   184  		"api-version": APIVersion,
   185  	}
   186  
   187  	preparer := autorest.CreatePreparer(
   188  		autorest.AsContentType("application/json; charset=utf-8"),
   189  		autorest.AsPut(),
   190  		autorest.WithBaseURL(client.BaseURI),
   191  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
   192  		autorest.WithJSON(createUpdateParameters),
   193  		autorest.WithQueryParameters(queryParameters))
   194  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   195  }
   196  
   197  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   198  // http.Response Body if it receives an error.
   199  func (client DatabaseAccountsClient) CreateOrUpdateSender(req *http.Request) (future DatabaseAccountsCreateOrUpdateFuture, err error) {
   200  	var resp *http.Response
   201  	future.FutureAPI = &azure.Future{}
   202  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   203  	if err != nil {
   204  		return
   205  	}
   206  	var azf azure.Future
   207  	azf, err = azure.NewFutureFromResponse(resp)
   208  	future.FutureAPI = &azf
   209  	future.Result = future.result
   210  	return
   211  }
   212  
   213  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   214  // closes the http.Response Body.
   215  func (client DatabaseAccountsClient) CreateOrUpdateResponder(resp *http.Response) (result DatabaseAccount, err error) {
   216  	err = autorest.Respond(
   217  		resp,
   218  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   219  		autorest.ByUnmarshallingJSON(&result),
   220  		autorest.ByClosing())
   221  	result.Response = autorest.Response{Response: resp}
   222  	return
   223  }
   224  
   225  // CreateUpdateCassandraKeyspace create or update an Azure Cosmos DB Cassandra keyspace
   226  // Parameters:
   227  // resourceGroupName - name of an Azure resource group.
   228  // accountName - cosmos DB database account name.
   229  // keyspaceName - cosmos DB keyspace name.
   230  // createUpdateCassandraKeyspaceParameters - the parameters to provide for the current Cassandra keyspace.
   231  func (client DatabaseAccountsClient) CreateUpdateCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, createUpdateCassandraKeyspaceParameters CassandraKeyspaceCreateUpdateParameters) (result DatabaseAccountsCreateUpdateCassandraKeyspaceFuture, err error) {
   232  	if tracing.IsEnabled() {
   233  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateCassandraKeyspace")
   234  		defer func() {
   235  			sc := -1
   236  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   237  				sc = result.FutureAPI.Response().StatusCode
   238  			}
   239  			tracing.EndSpan(ctx, sc, err)
   240  		}()
   241  	}
   242  	if err := validation.Validate([]validation.Validation{
   243  		{TargetValue: resourceGroupName,
   244  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   245  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   246  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   247  		{TargetValue: accountName,
   248  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   249  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   250  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   251  		{TargetValue: createUpdateCassandraKeyspaceParameters,
   252  			Constraints: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties", Name: validation.Null, Rule: true,
   253  				Chain: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   254  					Chain: []validation.Constraint{{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   255  					{Target: "createUpdateCassandraKeyspaceParameters.CassandraKeyspaceCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   256  				}}}}}); err != nil {
   257  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateCassandraKeyspace", err.Error())
   258  	}
   259  
   260  	req, err := client.CreateUpdateCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName, createUpdateCassandraKeyspaceParameters)
   261  	if err != nil {
   262  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateCassandraKeyspace", nil, "Failure preparing request")
   263  		return
   264  	}
   265  
   266  	result, err = client.CreateUpdateCassandraKeyspaceSender(req)
   267  	if err != nil {
   268  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateCassandraKeyspace", result.Response(), "Failure sending request")
   269  		return
   270  	}
   271  
   272  	return
   273  }
   274  
   275  // CreateUpdateCassandraKeyspacePreparer prepares the CreateUpdateCassandraKeyspace request.
   276  func (client DatabaseAccountsClient) CreateUpdateCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, createUpdateCassandraKeyspaceParameters CassandraKeyspaceCreateUpdateParameters) (*http.Request, error) {
   277  	pathParameters := map[string]interface{}{
   278  		"accountName":       autorest.Encode("path", accountName),
   279  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   280  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   281  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   282  	}
   283  
   284  	const APIVersion = "2015-04-08"
   285  	queryParameters := map[string]interface{}{
   286  		"api-version": APIVersion,
   287  	}
   288  
   289  	preparer := autorest.CreatePreparer(
   290  		autorest.AsContentType("application/json; charset=utf-8"),
   291  		autorest.AsPut(),
   292  		autorest.WithBaseURL(client.BaseURI),
   293  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}", pathParameters),
   294  		autorest.WithJSON(createUpdateCassandraKeyspaceParameters),
   295  		autorest.WithQueryParameters(queryParameters))
   296  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   297  }
   298  
   299  // CreateUpdateCassandraKeyspaceSender sends the CreateUpdateCassandraKeyspace request. The method will close the
   300  // http.Response Body if it receives an error.
   301  func (client DatabaseAccountsClient) CreateUpdateCassandraKeyspaceSender(req *http.Request) (future DatabaseAccountsCreateUpdateCassandraKeyspaceFuture, err error) {
   302  	var resp *http.Response
   303  	future.FutureAPI = &azure.Future{}
   304  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   305  	if err != nil {
   306  		return
   307  	}
   308  	var azf azure.Future
   309  	azf, err = azure.NewFutureFromResponse(resp)
   310  	future.FutureAPI = &azf
   311  	future.Result = future.result
   312  	return
   313  }
   314  
   315  // CreateUpdateCassandraKeyspaceResponder handles the response to the CreateUpdateCassandraKeyspace request. The method always
   316  // closes the http.Response Body.
   317  func (client DatabaseAccountsClient) CreateUpdateCassandraKeyspaceResponder(resp *http.Response) (result CassandraKeyspace, err error) {
   318  	err = autorest.Respond(
   319  		resp,
   320  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   321  		autorest.ByUnmarshallingJSON(&result),
   322  		autorest.ByClosing())
   323  	result.Response = autorest.Response{Response: resp}
   324  	return
   325  }
   326  
   327  // CreateUpdateCassandraTable create or update an Azure Cosmos DB Cassandra Table
   328  // Parameters:
   329  // resourceGroupName - name of an Azure resource group.
   330  // accountName - cosmos DB database account name.
   331  // keyspaceName - cosmos DB keyspace name.
   332  // tableName - cosmos DB table name.
   333  // createUpdateCassandraTableParameters - the parameters to provide for the current Cassandra Table.
   334  func (client DatabaseAccountsClient) CreateUpdateCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, createUpdateCassandraTableParameters CassandraTableCreateUpdateParameters) (result DatabaseAccountsCreateUpdateCassandraTableFuture, err error) {
   335  	if tracing.IsEnabled() {
   336  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateCassandraTable")
   337  		defer func() {
   338  			sc := -1
   339  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   340  				sc = result.FutureAPI.Response().StatusCode
   341  			}
   342  			tracing.EndSpan(ctx, sc, err)
   343  		}()
   344  	}
   345  	if err := validation.Validate([]validation.Validation{
   346  		{TargetValue: resourceGroupName,
   347  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   348  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   349  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   350  		{TargetValue: accountName,
   351  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   352  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   353  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   354  		{TargetValue: createUpdateCassandraTableParameters,
   355  			Constraints: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties", Name: validation.Null, Rule: true,
   356  				Chain: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   357  					Chain: []validation.Constraint{{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   358  					{Target: "createUpdateCassandraTableParameters.CassandraTableCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   359  				}}}}}); err != nil {
   360  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateCassandraTable", err.Error())
   361  	}
   362  
   363  	req, err := client.CreateUpdateCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName, createUpdateCassandraTableParameters)
   364  	if err != nil {
   365  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateCassandraTable", nil, "Failure preparing request")
   366  		return
   367  	}
   368  
   369  	result, err = client.CreateUpdateCassandraTableSender(req)
   370  	if err != nil {
   371  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateCassandraTable", result.Response(), "Failure sending request")
   372  		return
   373  	}
   374  
   375  	return
   376  }
   377  
   378  // CreateUpdateCassandraTablePreparer prepares the CreateUpdateCassandraTable request.
   379  func (client DatabaseAccountsClient) CreateUpdateCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, createUpdateCassandraTableParameters CassandraTableCreateUpdateParameters) (*http.Request, error) {
   380  	pathParameters := map[string]interface{}{
   381  		"accountName":       autorest.Encode("path", accountName),
   382  		"keyspaceName":      autorest.Encode("path", keyspaceName),
   383  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   384  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   385  		"tableName":         autorest.Encode("path", tableName),
   386  	}
   387  
   388  	const APIVersion = "2015-04-08"
   389  	queryParameters := map[string]interface{}{
   390  		"api-version": APIVersion,
   391  	}
   392  
   393  	preparer := autorest.CreatePreparer(
   394  		autorest.AsContentType("application/json; charset=utf-8"),
   395  		autorest.AsPut(),
   396  		autorest.WithBaseURL(client.BaseURI),
   397  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
   398  		autorest.WithJSON(createUpdateCassandraTableParameters),
   399  		autorest.WithQueryParameters(queryParameters))
   400  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   401  }
   402  
   403  // CreateUpdateCassandraTableSender sends the CreateUpdateCassandraTable request. The method will close the
   404  // http.Response Body if it receives an error.
   405  func (client DatabaseAccountsClient) CreateUpdateCassandraTableSender(req *http.Request) (future DatabaseAccountsCreateUpdateCassandraTableFuture, err error) {
   406  	var resp *http.Response
   407  	future.FutureAPI = &azure.Future{}
   408  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   409  	if err != nil {
   410  		return
   411  	}
   412  	var azf azure.Future
   413  	azf, err = azure.NewFutureFromResponse(resp)
   414  	future.FutureAPI = &azf
   415  	future.Result = future.result
   416  	return
   417  }
   418  
   419  // CreateUpdateCassandraTableResponder handles the response to the CreateUpdateCassandraTable request. The method always
   420  // closes the http.Response Body.
   421  func (client DatabaseAccountsClient) CreateUpdateCassandraTableResponder(resp *http.Response) (result CassandraTable, err error) {
   422  	err = autorest.Respond(
   423  		resp,
   424  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   425  		autorest.ByUnmarshallingJSON(&result),
   426  		autorest.ByClosing())
   427  	result.Response = autorest.Response{Response: resp}
   428  	return
   429  }
   430  
   431  // CreateUpdateGremlinDatabase create or update an Azure Cosmos DB Gremlin database
   432  // Parameters:
   433  // resourceGroupName - name of an Azure resource group.
   434  // accountName - cosmos DB database account name.
   435  // databaseName - cosmos DB database name.
   436  // createUpdateGremlinDatabaseParameters - the parameters to provide for the current Gremlin database.
   437  func (client DatabaseAccountsClient) CreateUpdateGremlinDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateGremlinDatabaseParameters GremlinDatabaseCreateUpdateParameters) (result DatabaseAccountsCreateUpdateGremlinDatabaseFuture, err error) {
   438  	if tracing.IsEnabled() {
   439  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateGremlinDatabase")
   440  		defer func() {
   441  			sc := -1
   442  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   443  				sc = result.FutureAPI.Response().StatusCode
   444  			}
   445  			tracing.EndSpan(ctx, sc, err)
   446  		}()
   447  	}
   448  	if err := validation.Validate([]validation.Validation{
   449  		{TargetValue: resourceGroupName,
   450  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   451  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   452  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   453  		{TargetValue: accountName,
   454  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   455  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   456  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   457  		{TargetValue: createUpdateGremlinDatabaseParameters,
   458  			Constraints: []validation.Constraint{{Target: "createUpdateGremlinDatabaseParameters.GremlinDatabaseCreateUpdateProperties", Name: validation.Null, Rule: true,
   459  				Chain: []validation.Constraint{{Target: "createUpdateGremlinDatabaseParameters.GremlinDatabaseCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   460  					Chain: []validation.Constraint{{Target: "createUpdateGremlinDatabaseParameters.GremlinDatabaseCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   461  					{Target: "createUpdateGremlinDatabaseParameters.GremlinDatabaseCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   462  				}}}}}); err != nil {
   463  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateGremlinDatabase", err.Error())
   464  	}
   465  
   466  	req, err := client.CreateUpdateGremlinDatabasePreparer(ctx, resourceGroupName, accountName, databaseName, createUpdateGremlinDatabaseParameters)
   467  	if err != nil {
   468  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateGremlinDatabase", nil, "Failure preparing request")
   469  		return
   470  	}
   471  
   472  	result, err = client.CreateUpdateGremlinDatabaseSender(req)
   473  	if err != nil {
   474  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateGremlinDatabase", result.Response(), "Failure sending request")
   475  		return
   476  	}
   477  
   478  	return
   479  }
   480  
   481  // CreateUpdateGremlinDatabasePreparer prepares the CreateUpdateGremlinDatabase request.
   482  func (client DatabaseAccountsClient) CreateUpdateGremlinDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateGremlinDatabaseParameters GremlinDatabaseCreateUpdateParameters) (*http.Request, error) {
   483  	pathParameters := map[string]interface{}{
   484  		"accountName":       autorest.Encode("path", accountName),
   485  		"databaseName":      autorest.Encode("path", databaseName),
   486  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   487  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   488  	}
   489  
   490  	const APIVersion = "2015-04-08"
   491  	queryParameters := map[string]interface{}{
   492  		"api-version": APIVersion,
   493  	}
   494  
   495  	preparer := autorest.CreatePreparer(
   496  		autorest.AsContentType("application/json; charset=utf-8"),
   497  		autorest.AsPut(),
   498  		autorest.WithBaseURL(client.BaseURI),
   499  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}", pathParameters),
   500  		autorest.WithJSON(createUpdateGremlinDatabaseParameters),
   501  		autorest.WithQueryParameters(queryParameters))
   502  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   503  }
   504  
   505  // CreateUpdateGremlinDatabaseSender sends the CreateUpdateGremlinDatabase request. The method will close the
   506  // http.Response Body if it receives an error.
   507  func (client DatabaseAccountsClient) CreateUpdateGremlinDatabaseSender(req *http.Request) (future DatabaseAccountsCreateUpdateGremlinDatabaseFuture, err error) {
   508  	var resp *http.Response
   509  	future.FutureAPI = &azure.Future{}
   510  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   511  	if err != nil {
   512  		return
   513  	}
   514  	var azf azure.Future
   515  	azf, err = azure.NewFutureFromResponse(resp)
   516  	future.FutureAPI = &azf
   517  	future.Result = future.result
   518  	return
   519  }
   520  
   521  // CreateUpdateGremlinDatabaseResponder handles the response to the CreateUpdateGremlinDatabase request. The method always
   522  // closes the http.Response Body.
   523  func (client DatabaseAccountsClient) CreateUpdateGremlinDatabaseResponder(resp *http.Response) (result GremlinDatabase, err error) {
   524  	err = autorest.Respond(
   525  		resp,
   526  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   527  		autorest.ByUnmarshallingJSON(&result),
   528  		autorest.ByClosing())
   529  	result.Response = autorest.Response{Response: resp}
   530  	return
   531  }
   532  
   533  // CreateUpdateGremlinGraph create or update an Azure Cosmos DB Gremlin graph
   534  // Parameters:
   535  // resourceGroupName - name of an Azure resource group.
   536  // accountName - cosmos DB database account name.
   537  // databaseName - cosmos DB database name.
   538  // graphName - cosmos DB graph name.
   539  // createUpdateGremlinGraphParameters - the parameters to provide for the current Gremlin graph.
   540  func (client DatabaseAccountsClient) CreateUpdateGremlinGraph(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string, createUpdateGremlinGraphParameters GremlinGraphCreateUpdateParameters) (result DatabaseAccountsCreateUpdateGremlinGraphFuture, err error) {
   541  	if tracing.IsEnabled() {
   542  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateGremlinGraph")
   543  		defer func() {
   544  			sc := -1
   545  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   546  				sc = result.FutureAPI.Response().StatusCode
   547  			}
   548  			tracing.EndSpan(ctx, sc, err)
   549  		}()
   550  	}
   551  	if err := validation.Validate([]validation.Validation{
   552  		{TargetValue: resourceGroupName,
   553  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   554  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   555  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   556  		{TargetValue: accountName,
   557  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   558  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   559  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   560  		{TargetValue: createUpdateGremlinGraphParameters,
   561  			Constraints: []validation.Constraint{{Target: "createUpdateGremlinGraphParameters.GremlinGraphCreateUpdateProperties", Name: validation.Null, Rule: true,
   562  				Chain: []validation.Constraint{{Target: "createUpdateGremlinGraphParameters.GremlinGraphCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   563  					Chain: []validation.Constraint{{Target: "createUpdateGremlinGraphParameters.GremlinGraphCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   564  					{Target: "createUpdateGremlinGraphParameters.GremlinGraphCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   565  				}}}}}); err != nil {
   566  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateGremlinGraph", err.Error())
   567  	}
   568  
   569  	req, err := client.CreateUpdateGremlinGraphPreparer(ctx, resourceGroupName, accountName, databaseName, graphName, createUpdateGremlinGraphParameters)
   570  	if err != nil {
   571  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateGremlinGraph", nil, "Failure preparing request")
   572  		return
   573  	}
   574  
   575  	result, err = client.CreateUpdateGremlinGraphSender(req)
   576  	if err != nil {
   577  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateGremlinGraph", result.Response(), "Failure sending request")
   578  		return
   579  	}
   580  
   581  	return
   582  }
   583  
   584  // CreateUpdateGremlinGraphPreparer prepares the CreateUpdateGremlinGraph request.
   585  func (client DatabaseAccountsClient) CreateUpdateGremlinGraphPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string, createUpdateGremlinGraphParameters GremlinGraphCreateUpdateParameters) (*http.Request, error) {
   586  	pathParameters := map[string]interface{}{
   587  		"accountName":       autorest.Encode("path", accountName),
   588  		"databaseName":      autorest.Encode("path", databaseName),
   589  		"graphName":         autorest.Encode("path", graphName),
   590  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   591  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   592  	}
   593  
   594  	const APIVersion = "2015-04-08"
   595  	queryParameters := map[string]interface{}{
   596  		"api-version": APIVersion,
   597  	}
   598  
   599  	preparer := autorest.CreatePreparer(
   600  		autorest.AsContentType("application/json; charset=utf-8"),
   601  		autorest.AsPut(),
   602  		autorest.WithBaseURL(client.BaseURI),
   603  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs/{graphName}", pathParameters),
   604  		autorest.WithJSON(createUpdateGremlinGraphParameters),
   605  		autorest.WithQueryParameters(queryParameters))
   606  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   607  }
   608  
   609  // CreateUpdateGremlinGraphSender sends the CreateUpdateGremlinGraph request. The method will close the
   610  // http.Response Body if it receives an error.
   611  func (client DatabaseAccountsClient) CreateUpdateGremlinGraphSender(req *http.Request) (future DatabaseAccountsCreateUpdateGremlinGraphFuture, err error) {
   612  	var resp *http.Response
   613  	future.FutureAPI = &azure.Future{}
   614  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   615  	if err != nil {
   616  		return
   617  	}
   618  	var azf azure.Future
   619  	azf, err = azure.NewFutureFromResponse(resp)
   620  	future.FutureAPI = &azf
   621  	future.Result = future.result
   622  	return
   623  }
   624  
   625  // CreateUpdateGremlinGraphResponder handles the response to the CreateUpdateGremlinGraph request. The method always
   626  // closes the http.Response Body.
   627  func (client DatabaseAccountsClient) CreateUpdateGremlinGraphResponder(resp *http.Response) (result GremlinGraph, err error) {
   628  	err = autorest.Respond(
   629  		resp,
   630  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   631  		autorest.ByUnmarshallingJSON(&result),
   632  		autorest.ByClosing())
   633  	result.Response = autorest.Response{Response: resp}
   634  	return
   635  }
   636  
   637  // CreateUpdateMongoDBCollection create or update an Azure Cosmos DB MongoDB Collection
   638  // Parameters:
   639  // resourceGroupName - name of an Azure resource group.
   640  // accountName - cosmos DB database account name.
   641  // databaseName - cosmos DB database name.
   642  // collectionName - cosmos DB collection name.
   643  // createUpdateMongoDBCollectionParameters - the parameters to provide for the current MongoDB Collection.
   644  func (client DatabaseAccountsClient) CreateUpdateMongoDBCollection(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string, createUpdateMongoDBCollectionParameters MongoDBCollectionCreateUpdateParameters) (result DatabaseAccountsCreateUpdateMongoDBCollectionFuture, err error) {
   645  	if tracing.IsEnabled() {
   646  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateMongoDBCollection")
   647  		defer func() {
   648  			sc := -1
   649  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   650  				sc = result.FutureAPI.Response().StatusCode
   651  			}
   652  			tracing.EndSpan(ctx, sc, err)
   653  		}()
   654  	}
   655  	if err := validation.Validate([]validation.Validation{
   656  		{TargetValue: resourceGroupName,
   657  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   658  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   659  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   660  		{TargetValue: accountName,
   661  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   662  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   663  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   664  		{TargetValue: createUpdateMongoDBCollectionParameters,
   665  			Constraints: []validation.Constraint{{Target: "createUpdateMongoDBCollectionParameters.MongoDBCollectionCreateUpdateProperties", Name: validation.Null, Rule: true,
   666  				Chain: []validation.Constraint{{Target: "createUpdateMongoDBCollectionParameters.MongoDBCollectionCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   667  					Chain: []validation.Constraint{{Target: "createUpdateMongoDBCollectionParameters.MongoDBCollectionCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   668  					{Target: "createUpdateMongoDBCollectionParameters.MongoDBCollectionCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   669  				}}}}}); err != nil {
   670  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBCollection", err.Error())
   671  	}
   672  
   673  	req, err := client.CreateUpdateMongoDBCollectionPreparer(ctx, resourceGroupName, accountName, databaseName, collectionName, createUpdateMongoDBCollectionParameters)
   674  	if err != nil {
   675  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBCollection", nil, "Failure preparing request")
   676  		return
   677  	}
   678  
   679  	result, err = client.CreateUpdateMongoDBCollectionSender(req)
   680  	if err != nil {
   681  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBCollection", result.Response(), "Failure sending request")
   682  		return
   683  	}
   684  
   685  	return
   686  }
   687  
   688  // CreateUpdateMongoDBCollectionPreparer prepares the CreateUpdateMongoDBCollection request.
   689  func (client DatabaseAccountsClient) CreateUpdateMongoDBCollectionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string, createUpdateMongoDBCollectionParameters MongoDBCollectionCreateUpdateParameters) (*http.Request, error) {
   690  	pathParameters := map[string]interface{}{
   691  		"accountName":       autorest.Encode("path", accountName),
   692  		"collectionName":    autorest.Encode("path", collectionName),
   693  		"databaseName":      autorest.Encode("path", databaseName),
   694  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   695  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   696  	}
   697  
   698  	const APIVersion = "2015-04-08"
   699  	queryParameters := map[string]interface{}{
   700  		"api-version": APIVersion,
   701  	}
   702  
   703  	preparer := autorest.CreatePreparer(
   704  		autorest.AsContentType("application/json; charset=utf-8"),
   705  		autorest.AsPut(),
   706  		autorest.WithBaseURL(client.BaseURI),
   707  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections/{collectionName}", pathParameters),
   708  		autorest.WithJSON(createUpdateMongoDBCollectionParameters),
   709  		autorest.WithQueryParameters(queryParameters))
   710  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   711  }
   712  
   713  // CreateUpdateMongoDBCollectionSender sends the CreateUpdateMongoDBCollection request. The method will close the
   714  // http.Response Body if it receives an error.
   715  func (client DatabaseAccountsClient) CreateUpdateMongoDBCollectionSender(req *http.Request) (future DatabaseAccountsCreateUpdateMongoDBCollectionFuture, err error) {
   716  	var resp *http.Response
   717  	future.FutureAPI = &azure.Future{}
   718  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   719  	if err != nil {
   720  		return
   721  	}
   722  	var azf azure.Future
   723  	azf, err = azure.NewFutureFromResponse(resp)
   724  	future.FutureAPI = &azf
   725  	future.Result = future.result
   726  	return
   727  }
   728  
   729  // CreateUpdateMongoDBCollectionResponder handles the response to the CreateUpdateMongoDBCollection request. The method always
   730  // closes the http.Response Body.
   731  func (client DatabaseAccountsClient) CreateUpdateMongoDBCollectionResponder(resp *http.Response) (result MongoDBCollection, err error) {
   732  	err = autorest.Respond(
   733  		resp,
   734  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   735  		autorest.ByUnmarshallingJSON(&result),
   736  		autorest.ByClosing())
   737  	result.Response = autorest.Response{Response: resp}
   738  	return
   739  }
   740  
   741  // CreateUpdateMongoDBDatabase create or updates Azure Cosmos DB MongoDB database
   742  // Parameters:
   743  // resourceGroupName - name of an Azure resource group.
   744  // accountName - cosmos DB database account name.
   745  // databaseName - cosmos DB database name.
   746  // createUpdateMongoDBDatabaseParameters - the parameters to provide for the current MongoDB database.
   747  func (client DatabaseAccountsClient) CreateUpdateMongoDBDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateMongoDBDatabaseParameters MongoDBDatabaseCreateUpdateParameters) (result DatabaseAccountsCreateUpdateMongoDBDatabaseFuture, err error) {
   748  	if tracing.IsEnabled() {
   749  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateMongoDBDatabase")
   750  		defer func() {
   751  			sc := -1
   752  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   753  				sc = result.FutureAPI.Response().StatusCode
   754  			}
   755  			tracing.EndSpan(ctx, sc, err)
   756  		}()
   757  	}
   758  	if err := validation.Validate([]validation.Validation{
   759  		{TargetValue: resourceGroupName,
   760  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   761  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   762  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   763  		{TargetValue: accountName,
   764  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   765  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   766  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   767  		{TargetValue: createUpdateMongoDBDatabaseParameters,
   768  			Constraints: []validation.Constraint{{Target: "createUpdateMongoDBDatabaseParameters.MongoDBDatabaseCreateUpdateProperties", Name: validation.Null, Rule: true,
   769  				Chain: []validation.Constraint{{Target: "createUpdateMongoDBDatabaseParameters.MongoDBDatabaseCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   770  					Chain: []validation.Constraint{{Target: "createUpdateMongoDBDatabaseParameters.MongoDBDatabaseCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   771  					{Target: "createUpdateMongoDBDatabaseParameters.MongoDBDatabaseCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   772  				}}}}}); err != nil {
   773  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBDatabase", err.Error())
   774  	}
   775  
   776  	req, err := client.CreateUpdateMongoDBDatabasePreparer(ctx, resourceGroupName, accountName, databaseName, createUpdateMongoDBDatabaseParameters)
   777  	if err != nil {
   778  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBDatabase", nil, "Failure preparing request")
   779  		return
   780  	}
   781  
   782  	result, err = client.CreateUpdateMongoDBDatabaseSender(req)
   783  	if err != nil {
   784  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateMongoDBDatabase", result.Response(), "Failure sending request")
   785  		return
   786  	}
   787  
   788  	return
   789  }
   790  
   791  // CreateUpdateMongoDBDatabasePreparer prepares the CreateUpdateMongoDBDatabase request.
   792  func (client DatabaseAccountsClient) CreateUpdateMongoDBDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateMongoDBDatabaseParameters MongoDBDatabaseCreateUpdateParameters) (*http.Request, error) {
   793  	pathParameters := map[string]interface{}{
   794  		"accountName":       autorest.Encode("path", accountName),
   795  		"databaseName":      autorest.Encode("path", databaseName),
   796  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   797  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   798  	}
   799  
   800  	const APIVersion = "2015-04-08"
   801  	queryParameters := map[string]interface{}{
   802  		"api-version": APIVersion,
   803  	}
   804  
   805  	preparer := autorest.CreatePreparer(
   806  		autorest.AsContentType("application/json; charset=utf-8"),
   807  		autorest.AsPut(),
   808  		autorest.WithBaseURL(client.BaseURI),
   809  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}", pathParameters),
   810  		autorest.WithJSON(createUpdateMongoDBDatabaseParameters),
   811  		autorest.WithQueryParameters(queryParameters))
   812  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   813  }
   814  
   815  // CreateUpdateMongoDBDatabaseSender sends the CreateUpdateMongoDBDatabase request. The method will close the
   816  // http.Response Body if it receives an error.
   817  func (client DatabaseAccountsClient) CreateUpdateMongoDBDatabaseSender(req *http.Request) (future DatabaseAccountsCreateUpdateMongoDBDatabaseFuture, err error) {
   818  	var resp *http.Response
   819  	future.FutureAPI = &azure.Future{}
   820  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   821  	if err != nil {
   822  		return
   823  	}
   824  	var azf azure.Future
   825  	azf, err = azure.NewFutureFromResponse(resp)
   826  	future.FutureAPI = &azf
   827  	future.Result = future.result
   828  	return
   829  }
   830  
   831  // CreateUpdateMongoDBDatabaseResponder handles the response to the CreateUpdateMongoDBDatabase request. The method always
   832  // closes the http.Response Body.
   833  func (client DatabaseAccountsClient) CreateUpdateMongoDBDatabaseResponder(resp *http.Response) (result MongoDBDatabase, err error) {
   834  	err = autorest.Respond(
   835  		resp,
   836  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   837  		autorest.ByUnmarshallingJSON(&result),
   838  		autorest.ByClosing())
   839  	result.Response = autorest.Response{Response: resp}
   840  	return
   841  }
   842  
   843  // CreateUpdateSQLContainer create or update an Azure Cosmos DB SQL container
   844  // Parameters:
   845  // resourceGroupName - name of an Azure resource group.
   846  // accountName - cosmos DB database account name.
   847  // databaseName - cosmos DB database name.
   848  // containerName - cosmos DB container name.
   849  // createUpdateSQLContainerParameters - the parameters to provide for the current SQL container.
   850  func (client DatabaseAccountsClient) CreateUpdateSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, createUpdateSQLContainerParameters SQLContainerCreateUpdateParameters) (result DatabaseAccountsCreateUpdateSQLContainerFuture, err error) {
   851  	if tracing.IsEnabled() {
   852  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateSQLContainer")
   853  		defer func() {
   854  			sc := -1
   855  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   856  				sc = result.FutureAPI.Response().StatusCode
   857  			}
   858  			tracing.EndSpan(ctx, sc, err)
   859  		}()
   860  	}
   861  	if err := validation.Validate([]validation.Validation{
   862  		{TargetValue: resourceGroupName,
   863  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   864  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   865  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   866  		{TargetValue: accountName,
   867  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   868  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   869  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   870  		{TargetValue: createUpdateSQLContainerParameters,
   871  			Constraints: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties", Name: validation.Null, Rule: true,
   872  				Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   873  					Chain: []validation.Constraint{{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   874  					{Target: "createUpdateSQLContainerParameters.SQLContainerCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   875  				}}}}}); err != nil {
   876  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateSQLContainer", err.Error())
   877  	}
   878  
   879  	req, err := client.CreateUpdateSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, createUpdateSQLContainerParameters)
   880  	if err != nil {
   881  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateSQLContainer", nil, "Failure preparing request")
   882  		return
   883  	}
   884  
   885  	result, err = client.CreateUpdateSQLContainerSender(req)
   886  	if err != nil {
   887  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateSQLContainer", result.Response(), "Failure sending request")
   888  		return
   889  	}
   890  
   891  	return
   892  }
   893  
   894  // CreateUpdateSQLContainerPreparer prepares the CreateUpdateSQLContainer request.
   895  func (client DatabaseAccountsClient) CreateUpdateSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, createUpdateSQLContainerParameters SQLContainerCreateUpdateParameters) (*http.Request, error) {
   896  	pathParameters := map[string]interface{}{
   897  		"accountName":       autorest.Encode("path", accountName),
   898  		"containerName":     autorest.Encode("path", containerName),
   899  		"databaseName":      autorest.Encode("path", databaseName),
   900  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   901  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   902  	}
   903  
   904  	const APIVersion = "2015-04-08"
   905  	queryParameters := map[string]interface{}{
   906  		"api-version": APIVersion,
   907  	}
   908  
   909  	preparer := autorest.CreatePreparer(
   910  		autorest.AsContentType("application/json; charset=utf-8"),
   911  		autorest.AsPut(),
   912  		autorest.WithBaseURL(client.BaseURI),
   913  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers/{containerName}", pathParameters),
   914  		autorest.WithJSON(createUpdateSQLContainerParameters),
   915  		autorest.WithQueryParameters(queryParameters))
   916  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   917  }
   918  
   919  // CreateUpdateSQLContainerSender sends the CreateUpdateSQLContainer request. The method will close the
   920  // http.Response Body if it receives an error.
   921  func (client DatabaseAccountsClient) CreateUpdateSQLContainerSender(req *http.Request) (future DatabaseAccountsCreateUpdateSQLContainerFuture, err error) {
   922  	var resp *http.Response
   923  	future.FutureAPI = &azure.Future{}
   924  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   925  	if err != nil {
   926  		return
   927  	}
   928  	var azf azure.Future
   929  	azf, err = azure.NewFutureFromResponse(resp)
   930  	future.FutureAPI = &azf
   931  	future.Result = future.result
   932  	return
   933  }
   934  
   935  // CreateUpdateSQLContainerResponder handles the response to the CreateUpdateSQLContainer request. The method always
   936  // closes the http.Response Body.
   937  func (client DatabaseAccountsClient) CreateUpdateSQLContainerResponder(resp *http.Response) (result SQLContainer, err error) {
   938  	err = autorest.Respond(
   939  		resp,
   940  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   941  		autorest.ByUnmarshallingJSON(&result),
   942  		autorest.ByClosing())
   943  	result.Response = autorest.Response{Response: resp}
   944  	return
   945  }
   946  
   947  // CreateUpdateSQLDatabase create or update an Azure Cosmos DB SQL database
   948  // Parameters:
   949  // resourceGroupName - name of an Azure resource group.
   950  // accountName - cosmos DB database account name.
   951  // databaseName - cosmos DB database name.
   952  // createUpdateSQLDatabaseParameters - the parameters to provide for the current SQL database.
   953  func (client DatabaseAccountsClient) CreateUpdateSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateSQLDatabaseParameters SQLDatabaseCreateUpdateParameters) (result DatabaseAccountsCreateUpdateSQLDatabaseFuture, err error) {
   954  	if tracing.IsEnabled() {
   955  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateSQLDatabase")
   956  		defer func() {
   957  			sc := -1
   958  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   959  				sc = result.FutureAPI.Response().StatusCode
   960  			}
   961  			tracing.EndSpan(ctx, sc, err)
   962  		}()
   963  	}
   964  	if err := validation.Validate([]validation.Validation{
   965  		{TargetValue: resourceGroupName,
   966  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   967  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   968  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   969  		{TargetValue: accountName,
   970  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   971  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   972  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   973  		{TargetValue: createUpdateSQLDatabaseParameters,
   974  			Constraints: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties", Name: validation.Null, Rule: true,
   975  				Chain: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
   976  					Chain: []validation.Constraint{{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
   977  					{Target: "createUpdateSQLDatabaseParameters.SQLDatabaseCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
   978  				}}}}}); err != nil {
   979  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateSQLDatabase", err.Error())
   980  	}
   981  
   982  	req, err := client.CreateUpdateSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName, createUpdateSQLDatabaseParameters)
   983  	if err != nil {
   984  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateSQLDatabase", nil, "Failure preparing request")
   985  		return
   986  	}
   987  
   988  	result, err = client.CreateUpdateSQLDatabaseSender(req)
   989  	if err != nil {
   990  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateSQLDatabase", result.Response(), "Failure sending request")
   991  		return
   992  	}
   993  
   994  	return
   995  }
   996  
   997  // CreateUpdateSQLDatabasePreparer prepares the CreateUpdateSQLDatabase request.
   998  func (client DatabaseAccountsClient) CreateUpdateSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, createUpdateSQLDatabaseParameters SQLDatabaseCreateUpdateParameters) (*http.Request, error) {
   999  	pathParameters := map[string]interface{}{
  1000  		"accountName":       autorest.Encode("path", accountName),
  1001  		"databaseName":      autorest.Encode("path", databaseName),
  1002  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1003  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1004  	}
  1005  
  1006  	const APIVersion = "2015-04-08"
  1007  	queryParameters := map[string]interface{}{
  1008  		"api-version": APIVersion,
  1009  	}
  1010  
  1011  	preparer := autorest.CreatePreparer(
  1012  		autorest.AsContentType("application/json; charset=utf-8"),
  1013  		autorest.AsPut(),
  1014  		autorest.WithBaseURL(client.BaseURI),
  1015  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}", pathParameters),
  1016  		autorest.WithJSON(createUpdateSQLDatabaseParameters),
  1017  		autorest.WithQueryParameters(queryParameters))
  1018  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1019  }
  1020  
  1021  // CreateUpdateSQLDatabaseSender sends the CreateUpdateSQLDatabase request. The method will close the
  1022  // http.Response Body if it receives an error.
  1023  func (client DatabaseAccountsClient) CreateUpdateSQLDatabaseSender(req *http.Request) (future DatabaseAccountsCreateUpdateSQLDatabaseFuture, err error) {
  1024  	var resp *http.Response
  1025  	future.FutureAPI = &azure.Future{}
  1026  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1027  	if err != nil {
  1028  		return
  1029  	}
  1030  	var azf azure.Future
  1031  	azf, err = azure.NewFutureFromResponse(resp)
  1032  	future.FutureAPI = &azf
  1033  	future.Result = future.result
  1034  	return
  1035  }
  1036  
  1037  // CreateUpdateSQLDatabaseResponder handles the response to the CreateUpdateSQLDatabase request. The method always
  1038  // closes the http.Response Body.
  1039  func (client DatabaseAccountsClient) CreateUpdateSQLDatabaseResponder(resp *http.Response) (result SQLDatabase, err error) {
  1040  	err = autorest.Respond(
  1041  		resp,
  1042  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1043  		autorest.ByUnmarshallingJSON(&result),
  1044  		autorest.ByClosing())
  1045  	result.Response = autorest.Response{Response: resp}
  1046  	return
  1047  }
  1048  
  1049  // CreateUpdateTable create or update an Azure Cosmos DB Table
  1050  // Parameters:
  1051  // resourceGroupName - name of an Azure resource group.
  1052  // accountName - cosmos DB database account name.
  1053  // tableName - cosmos DB table name.
  1054  // createUpdateTableParameters - the parameters to provide for the current Table.
  1055  func (client DatabaseAccountsClient) CreateUpdateTable(ctx context.Context, resourceGroupName string, accountName string, tableName string, createUpdateTableParameters TableCreateUpdateParameters) (result DatabaseAccountsCreateUpdateTableFuture, err error) {
  1056  	if tracing.IsEnabled() {
  1057  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateUpdateTable")
  1058  		defer func() {
  1059  			sc := -1
  1060  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1061  				sc = result.FutureAPI.Response().StatusCode
  1062  			}
  1063  			tracing.EndSpan(ctx, sc, err)
  1064  		}()
  1065  	}
  1066  	if err := validation.Validate([]validation.Validation{
  1067  		{TargetValue: resourceGroupName,
  1068  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1069  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1070  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1071  		{TargetValue: accountName,
  1072  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1073  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1074  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  1075  		{TargetValue: createUpdateTableParameters,
  1076  			Constraints: []validation.Constraint{{Target: "createUpdateTableParameters.TableCreateUpdateProperties", Name: validation.Null, Rule: true,
  1077  				Chain: []validation.Constraint{{Target: "createUpdateTableParameters.TableCreateUpdateProperties.Resource", Name: validation.Null, Rule: true,
  1078  					Chain: []validation.Constraint{{Target: "createUpdateTableParameters.TableCreateUpdateProperties.Resource.ID", Name: validation.Null, Rule: true, Chain: nil}}},
  1079  					{Target: "createUpdateTableParameters.TableCreateUpdateProperties.Options", Name: validation.Null, Rule: true, Chain: nil},
  1080  				}}}}}); err != nil {
  1081  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateUpdateTable", err.Error())
  1082  	}
  1083  
  1084  	req, err := client.CreateUpdateTablePreparer(ctx, resourceGroupName, accountName, tableName, createUpdateTableParameters)
  1085  	if err != nil {
  1086  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateTable", nil, "Failure preparing request")
  1087  		return
  1088  	}
  1089  
  1090  	result, err = client.CreateUpdateTableSender(req)
  1091  	if err != nil {
  1092  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateUpdateTable", result.Response(), "Failure sending request")
  1093  		return
  1094  	}
  1095  
  1096  	return
  1097  }
  1098  
  1099  // CreateUpdateTablePreparer prepares the CreateUpdateTable request.
  1100  func (client DatabaseAccountsClient) CreateUpdateTablePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string, createUpdateTableParameters TableCreateUpdateParameters) (*http.Request, error) {
  1101  	pathParameters := map[string]interface{}{
  1102  		"accountName":       autorest.Encode("path", accountName),
  1103  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1104  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1105  		"tableName":         autorest.Encode("path", tableName),
  1106  	}
  1107  
  1108  	const APIVersion = "2015-04-08"
  1109  	queryParameters := map[string]interface{}{
  1110  		"api-version": APIVersion,
  1111  	}
  1112  
  1113  	preparer := autorest.CreatePreparer(
  1114  		autorest.AsContentType("application/json; charset=utf-8"),
  1115  		autorest.AsPut(),
  1116  		autorest.WithBaseURL(client.BaseURI),
  1117  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables/{tableName}", pathParameters),
  1118  		autorest.WithJSON(createUpdateTableParameters),
  1119  		autorest.WithQueryParameters(queryParameters))
  1120  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1121  }
  1122  
  1123  // CreateUpdateTableSender sends the CreateUpdateTable request. The method will close the
  1124  // http.Response Body if it receives an error.
  1125  func (client DatabaseAccountsClient) CreateUpdateTableSender(req *http.Request) (future DatabaseAccountsCreateUpdateTableFuture, err error) {
  1126  	var resp *http.Response
  1127  	future.FutureAPI = &azure.Future{}
  1128  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1129  	if err != nil {
  1130  		return
  1131  	}
  1132  	var azf azure.Future
  1133  	azf, err = azure.NewFutureFromResponse(resp)
  1134  	future.FutureAPI = &azf
  1135  	future.Result = future.result
  1136  	return
  1137  }
  1138  
  1139  // CreateUpdateTableResponder handles the response to the CreateUpdateTable request. The method always
  1140  // closes the http.Response Body.
  1141  func (client DatabaseAccountsClient) CreateUpdateTableResponder(resp *http.Response) (result Table, err error) {
  1142  	err = autorest.Respond(
  1143  		resp,
  1144  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1145  		autorest.ByUnmarshallingJSON(&result),
  1146  		autorest.ByClosing())
  1147  	result.Response = autorest.Response{Response: resp}
  1148  	return
  1149  }
  1150  
  1151  // Delete deletes an existing Azure Cosmos DB database account.
  1152  // Parameters:
  1153  // resourceGroupName - name of an Azure resource group.
  1154  // accountName - cosmos DB database account name.
  1155  func (client DatabaseAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountsDeleteFuture, err error) {
  1156  	if tracing.IsEnabled() {
  1157  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Delete")
  1158  		defer func() {
  1159  			sc := -1
  1160  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1161  				sc = result.FutureAPI.Response().StatusCode
  1162  			}
  1163  			tracing.EndSpan(ctx, sc, err)
  1164  		}()
  1165  	}
  1166  	if err := validation.Validate([]validation.Validation{
  1167  		{TargetValue: resourceGroupName,
  1168  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1169  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1170  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1171  		{TargetValue: accountName,
  1172  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1173  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1174  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1175  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Delete", err.Error())
  1176  	}
  1177  
  1178  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
  1179  	if err != nil {
  1180  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Delete", nil, "Failure preparing request")
  1181  		return
  1182  	}
  1183  
  1184  	result, err = client.DeleteSender(req)
  1185  	if err != nil {
  1186  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Delete", result.Response(), "Failure sending request")
  1187  		return
  1188  	}
  1189  
  1190  	return
  1191  }
  1192  
  1193  // DeletePreparer prepares the Delete request.
  1194  func (client DatabaseAccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  1195  	pathParameters := map[string]interface{}{
  1196  		"accountName":       autorest.Encode("path", accountName),
  1197  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1198  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1199  	}
  1200  
  1201  	const APIVersion = "2015-04-08"
  1202  	queryParameters := map[string]interface{}{
  1203  		"api-version": APIVersion,
  1204  	}
  1205  
  1206  	preparer := autorest.CreatePreparer(
  1207  		autorest.AsDelete(),
  1208  		autorest.WithBaseURL(client.BaseURI),
  1209  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
  1210  		autorest.WithQueryParameters(queryParameters))
  1211  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1212  }
  1213  
  1214  // DeleteSender sends the Delete request. The method will close the
  1215  // http.Response Body if it receives an error.
  1216  func (client DatabaseAccountsClient) DeleteSender(req *http.Request) (future DatabaseAccountsDeleteFuture, err error) {
  1217  	var resp *http.Response
  1218  	future.FutureAPI = &azure.Future{}
  1219  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1220  	if err != nil {
  1221  		return
  1222  	}
  1223  	var azf azure.Future
  1224  	azf, err = azure.NewFutureFromResponse(resp)
  1225  	future.FutureAPI = &azf
  1226  	future.Result = future.result
  1227  	return
  1228  }
  1229  
  1230  // DeleteResponder handles the response to the Delete request. The method always
  1231  // closes the http.Response Body.
  1232  func (client DatabaseAccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
  1233  	err = autorest.Respond(
  1234  		resp,
  1235  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1236  		autorest.ByClosing())
  1237  	result.Response = resp
  1238  	return
  1239  }
  1240  
  1241  // DeleteCassandraKeyspace deletes an existing Azure Cosmos DB Cassandra keyspace.
  1242  // Parameters:
  1243  // resourceGroupName - name of an Azure resource group.
  1244  // accountName - cosmos DB database account name.
  1245  // keyspaceName - cosmos DB keyspace name.
  1246  func (client DatabaseAccountsClient) DeleteCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result DatabaseAccountsDeleteCassandraKeyspaceFuture, err error) {
  1247  	if tracing.IsEnabled() {
  1248  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteCassandraKeyspace")
  1249  		defer func() {
  1250  			sc := -1
  1251  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1252  				sc = result.FutureAPI.Response().StatusCode
  1253  			}
  1254  			tracing.EndSpan(ctx, sc, err)
  1255  		}()
  1256  	}
  1257  	if err := validation.Validate([]validation.Validation{
  1258  		{TargetValue: resourceGroupName,
  1259  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1260  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1261  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1262  		{TargetValue: accountName,
  1263  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1264  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1265  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1266  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteCassandraKeyspace", err.Error())
  1267  	}
  1268  
  1269  	req, err := client.DeleteCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName)
  1270  	if err != nil {
  1271  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteCassandraKeyspace", nil, "Failure preparing request")
  1272  		return
  1273  	}
  1274  
  1275  	result, err = client.DeleteCassandraKeyspaceSender(req)
  1276  	if err != nil {
  1277  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteCassandraKeyspace", result.Response(), "Failure sending request")
  1278  		return
  1279  	}
  1280  
  1281  	return
  1282  }
  1283  
  1284  // DeleteCassandraKeyspacePreparer prepares the DeleteCassandraKeyspace request.
  1285  func (client DatabaseAccountsClient) DeleteCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
  1286  	pathParameters := map[string]interface{}{
  1287  		"accountName":       autorest.Encode("path", accountName),
  1288  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  1289  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1290  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1291  	}
  1292  
  1293  	const APIVersion = "2015-04-08"
  1294  	queryParameters := map[string]interface{}{
  1295  		"api-version": APIVersion,
  1296  	}
  1297  
  1298  	preparer := autorest.CreatePreparer(
  1299  		autorest.AsDelete(),
  1300  		autorest.WithBaseURL(client.BaseURI),
  1301  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}", pathParameters),
  1302  		autorest.WithQueryParameters(queryParameters))
  1303  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1304  }
  1305  
  1306  // DeleteCassandraKeyspaceSender sends the DeleteCassandraKeyspace request. The method will close the
  1307  // http.Response Body if it receives an error.
  1308  func (client DatabaseAccountsClient) DeleteCassandraKeyspaceSender(req *http.Request) (future DatabaseAccountsDeleteCassandraKeyspaceFuture, err error) {
  1309  	var resp *http.Response
  1310  	future.FutureAPI = &azure.Future{}
  1311  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1312  	if err != nil {
  1313  		return
  1314  	}
  1315  	var azf azure.Future
  1316  	azf, err = azure.NewFutureFromResponse(resp)
  1317  	future.FutureAPI = &azf
  1318  	future.Result = future.result
  1319  	return
  1320  }
  1321  
  1322  // DeleteCassandraKeyspaceResponder handles the response to the DeleteCassandraKeyspace request. The method always
  1323  // closes the http.Response Body.
  1324  func (client DatabaseAccountsClient) DeleteCassandraKeyspaceResponder(resp *http.Response) (result autorest.Response, err error) {
  1325  	err = autorest.Respond(
  1326  		resp,
  1327  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1328  		autorest.ByClosing())
  1329  	result.Response = resp
  1330  	return
  1331  }
  1332  
  1333  // DeleteCassandraTable deletes an existing Azure Cosmos DB Cassandra table.
  1334  // Parameters:
  1335  // resourceGroupName - name of an Azure resource group.
  1336  // accountName - cosmos DB database account name.
  1337  // keyspaceName - cosmos DB keyspace name.
  1338  // tableName - cosmos DB table name.
  1339  func (client DatabaseAccountsClient) DeleteCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result DatabaseAccountsDeleteCassandraTableFuture, err error) {
  1340  	if tracing.IsEnabled() {
  1341  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteCassandraTable")
  1342  		defer func() {
  1343  			sc := -1
  1344  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1345  				sc = result.FutureAPI.Response().StatusCode
  1346  			}
  1347  			tracing.EndSpan(ctx, sc, err)
  1348  		}()
  1349  	}
  1350  	if err := validation.Validate([]validation.Validation{
  1351  		{TargetValue: resourceGroupName,
  1352  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1353  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1354  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1355  		{TargetValue: accountName,
  1356  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1357  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1358  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1359  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteCassandraTable", err.Error())
  1360  	}
  1361  
  1362  	req, err := client.DeleteCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
  1363  	if err != nil {
  1364  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteCassandraTable", nil, "Failure preparing request")
  1365  		return
  1366  	}
  1367  
  1368  	result, err = client.DeleteCassandraTableSender(req)
  1369  	if err != nil {
  1370  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteCassandraTable", result.Response(), "Failure sending request")
  1371  		return
  1372  	}
  1373  
  1374  	return
  1375  }
  1376  
  1377  // DeleteCassandraTablePreparer prepares the DeleteCassandraTable request.
  1378  func (client DatabaseAccountsClient) DeleteCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
  1379  	pathParameters := map[string]interface{}{
  1380  		"accountName":       autorest.Encode("path", accountName),
  1381  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  1382  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1383  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1384  		"tableName":         autorest.Encode("path", tableName),
  1385  	}
  1386  
  1387  	const APIVersion = "2015-04-08"
  1388  	queryParameters := map[string]interface{}{
  1389  		"api-version": APIVersion,
  1390  	}
  1391  
  1392  	preparer := autorest.CreatePreparer(
  1393  		autorest.AsDelete(),
  1394  		autorest.WithBaseURL(client.BaseURI),
  1395  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
  1396  		autorest.WithQueryParameters(queryParameters))
  1397  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1398  }
  1399  
  1400  // DeleteCassandraTableSender sends the DeleteCassandraTable request. The method will close the
  1401  // http.Response Body if it receives an error.
  1402  func (client DatabaseAccountsClient) DeleteCassandraTableSender(req *http.Request) (future DatabaseAccountsDeleteCassandraTableFuture, err error) {
  1403  	var resp *http.Response
  1404  	future.FutureAPI = &azure.Future{}
  1405  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1406  	if err != nil {
  1407  		return
  1408  	}
  1409  	var azf azure.Future
  1410  	azf, err = azure.NewFutureFromResponse(resp)
  1411  	future.FutureAPI = &azf
  1412  	future.Result = future.result
  1413  	return
  1414  }
  1415  
  1416  // DeleteCassandraTableResponder handles the response to the DeleteCassandraTable request. The method always
  1417  // closes the http.Response Body.
  1418  func (client DatabaseAccountsClient) DeleteCassandraTableResponder(resp *http.Response) (result autorest.Response, err error) {
  1419  	err = autorest.Respond(
  1420  		resp,
  1421  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1422  		autorest.ByClosing())
  1423  	result.Response = resp
  1424  	return
  1425  }
  1426  
  1427  // DeleteGremlinDatabase deletes an existing Azure Cosmos DB Gremlin database.
  1428  // Parameters:
  1429  // resourceGroupName - name of an Azure resource group.
  1430  // accountName - cosmos DB database account name.
  1431  // databaseName - cosmos DB database name.
  1432  func (client DatabaseAccountsClient) DeleteGremlinDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result DatabaseAccountsDeleteGremlinDatabaseFuture, err error) {
  1433  	if tracing.IsEnabled() {
  1434  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteGremlinDatabase")
  1435  		defer func() {
  1436  			sc := -1
  1437  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1438  				sc = result.FutureAPI.Response().StatusCode
  1439  			}
  1440  			tracing.EndSpan(ctx, sc, err)
  1441  		}()
  1442  	}
  1443  	if err := validation.Validate([]validation.Validation{
  1444  		{TargetValue: resourceGroupName,
  1445  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1446  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1447  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1448  		{TargetValue: accountName,
  1449  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1450  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1451  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1452  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteGremlinDatabase", err.Error())
  1453  	}
  1454  
  1455  	req, err := client.DeleteGremlinDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  1456  	if err != nil {
  1457  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteGremlinDatabase", nil, "Failure preparing request")
  1458  		return
  1459  	}
  1460  
  1461  	result, err = client.DeleteGremlinDatabaseSender(req)
  1462  	if err != nil {
  1463  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteGremlinDatabase", result.Response(), "Failure sending request")
  1464  		return
  1465  	}
  1466  
  1467  	return
  1468  }
  1469  
  1470  // DeleteGremlinDatabasePreparer prepares the DeleteGremlinDatabase request.
  1471  func (client DatabaseAccountsClient) DeleteGremlinDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  1472  	pathParameters := map[string]interface{}{
  1473  		"accountName":       autorest.Encode("path", accountName),
  1474  		"databaseName":      autorest.Encode("path", databaseName),
  1475  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1476  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1477  	}
  1478  
  1479  	const APIVersion = "2015-04-08"
  1480  	queryParameters := map[string]interface{}{
  1481  		"api-version": APIVersion,
  1482  	}
  1483  
  1484  	preparer := autorest.CreatePreparer(
  1485  		autorest.AsDelete(),
  1486  		autorest.WithBaseURL(client.BaseURI),
  1487  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}", pathParameters),
  1488  		autorest.WithQueryParameters(queryParameters))
  1489  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1490  }
  1491  
  1492  // DeleteGremlinDatabaseSender sends the DeleteGremlinDatabase request. The method will close the
  1493  // http.Response Body if it receives an error.
  1494  func (client DatabaseAccountsClient) DeleteGremlinDatabaseSender(req *http.Request) (future DatabaseAccountsDeleteGremlinDatabaseFuture, err error) {
  1495  	var resp *http.Response
  1496  	future.FutureAPI = &azure.Future{}
  1497  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1498  	if err != nil {
  1499  		return
  1500  	}
  1501  	var azf azure.Future
  1502  	azf, err = azure.NewFutureFromResponse(resp)
  1503  	future.FutureAPI = &azf
  1504  	future.Result = future.result
  1505  	return
  1506  }
  1507  
  1508  // DeleteGremlinDatabaseResponder handles the response to the DeleteGremlinDatabase request. The method always
  1509  // closes the http.Response Body.
  1510  func (client DatabaseAccountsClient) DeleteGremlinDatabaseResponder(resp *http.Response) (result autorest.Response, err error) {
  1511  	err = autorest.Respond(
  1512  		resp,
  1513  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1514  		autorest.ByClosing())
  1515  	result.Response = resp
  1516  	return
  1517  }
  1518  
  1519  // DeleteGremlinGraph deletes an existing Azure Cosmos DB Gremlin graph.
  1520  // Parameters:
  1521  // resourceGroupName - name of an Azure resource group.
  1522  // accountName - cosmos DB database account name.
  1523  // databaseName - cosmos DB database name.
  1524  // graphName - cosmos DB graph name.
  1525  func (client DatabaseAccountsClient) DeleteGremlinGraph(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (result DatabaseAccountsDeleteGremlinGraphFuture, err error) {
  1526  	if tracing.IsEnabled() {
  1527  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteGremlinGraph")
  1528  		defer func() {
  1529  			sc := -1
  1530  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1531  				sc = result.FutureAPI.Response().StatusCode
  1532  			}
  1533  			tracing.EndSpan(ctx, sc, err)
  1534  		}()
  1535  	}
  1536  	if err := validation.Validate([]validation.Validation{
  1537  		{TargetValue: resourceGroupName,
  1538  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1539  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1540  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1541  		{TargetValue: accountName,
  1542  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1543  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1544  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1545  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteGremlinGraph", err.Error())
  1546  	}
  1547  
  1548  	req, err := client.DeleteGremlinGraphPreparer(ctx, resourceGroupName, accountName, databaseName, graphName)
  1549  	if err != nil {
  1550  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteGremlinGraph", nil, "Failure preparing request")
  1551  		return
  1552  	}
  1553  
  1554  	result, err = client.DeleteGremlinGraphSender(req)
  1555  	if err != nil {
  1556  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteGremlinGraph", result.Response(), "Failure sending request")
  1557  		return
  1558  	}
  1559  
  1560  	return
  1561  }
  1562  
  1563  // DeleteGremlinGraphPreparer prepares the DeleteGremlinGraph request.
  1564  func (client DatabaseAccountsClient) DeleteGremlinGraphPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (*http.Request, error) {
  1565  	pathParameters := map[string]interface{}{
  1566  		"accountName":       autorest.Encode("path", accountName),
  1567  		"databaseName":      autorest.Encode("path", databaseName),
  1568  		"graphName":         autorest.Encode("path", graphName),
  1569  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1570  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1571  	}
  1572  
  1573  	const APIVersion = "2015-04-08"
  1574  	queryParameters := map[string]interface{}{
  1575  		"api-version": APIVersion,
  1576  	}
  1577  
  1578  	preparer := autorest.CreatePreparer(
  1579  		autorest.AsDelete(),
  1580  		autorest.WithBaseURL(client.BaseURI),
  1581  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs/{graphName}", pathParameters),
  1582  		autorest.WithQueryParameters(queryParameters))
  1583  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1584  }
  1585  
  1586  // DeleteGremlinGraphSender sends the DeleteGremlinGraph request. The method will close the
  1587  // http.Response Body if it receives an error.
  1588  func (client DatabaseAccountsClient) DeleteGremlinGraphSender(req *http.Request) (future DatabaseAccountsDeleteGremlinGraphFuture, err error) {
  1589  	var resp *http.Response
  1590  	future.FutureAPI = &azure.Future{}
  1591  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1592  	if err != nil {
  1593  		return
  1594  	}
  1595  	var azf azure.Future
  1596  	azf, err = azure.NewFutureFromResponse(resp)
  1597  	future.FutureAPI = &azf
  1598  	future.Result = future.result
  1599  	return
  1600  }
  1601  
  1602  // DeleteGremlinGraphResponder handles the response to the DeleteGremlinGraph request. The method always
  1603  // closes the http.Response Body.
  1604  func (client DatabaseAccountsClient) DeleteGremlinGraphResponder(resp *http.Response) (result autorest.Response, err error) {
  1605  	err = autorest.Respond(
  1606  		resp,
  1607  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1608  		autorest.ByClosing())
  1609  	result.Response = resp
  1610  	return
  1611  }
  1612  
  1613  // DeleteMongoDBCollection deletes an existing Azure Cosmos DB MongoDB Collection.
  1614  // Parameters:
  1615  // resourceGroupName - name of an Azure resource group.
  1616  // accountName - cosmos DB database account name.
  1617  // databaseName - cosmos DB database name.
  1618  // collectionName - cosmos DB collection name.
  1619  func (client DatabaseAccountsClient) DeleteMongoDBCollection(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (result DatabaseAccountsDeleteMongoDBCollectionFuture, err error) {
  1620  	if tracing.IsEnabled() {
  1621  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteMongoDBCollection")
  1622  		defer func() {
  1623  			sc := -1
  1624  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1625  				sc = result.FutureAPI.Response().StatusCode
  1626  			}
  1627  			tracing.EndSpan(ctx, sc, err)
  1628  		}()
  1629  	}
  1630  	if err := validation.Validate([]validation.Validation{
  1631  		{TargetValue: resourceGroupName,
  1632  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1633  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1634  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1635  		{TargetValue: accountName,
  1636  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1637  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1638  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1639  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteMongoDBCollection", err.Error())
  1640  	}
  1641  
  1642  	req, err := client.DeleteMongoDBCollectionPreparer(ctx, resourceGroupName, accountName, databaseName, collectionName)
  1643  	if err != nil {
  1644  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteMongoDBCollection", nil, "Failure preparing request")
  1645  		return
  1646  	}
  1647  
  1648  	result, err = client.DeleteMongoDBCollectionSender(req)
  1649  	if err != nil {
  1650  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteMongoDBCollection", result.Response(), "Failure sending request")
  1651  		return
  1652  	}
  1653  
  1654  	return
  1655  }
  1656  
  1657  // DeleteMongoDBCollectionPreparer prepares the DeleteMongoDBCollection request.
  1658  func (client DatabaseAccountsClient) DeleteMongoDBCollectionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (*http.Request, error) {
  1659  	pathParameters := map[string]interface{}{
  1660  		"accountName":       autorest.Encode("path", accountName),
  1661  		"collectionName":    autorest.Encode("path", collectionName),
  1662  		"databaseName":      autorest.Encode("path", databaseName),
  1663  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1664  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1665  	}
  1666  
  1667  	const APIVersion = "2015-04-08"
  1668  	queryParameters := map[string]interface{}{
  1669  		"api-version": APIVersion,
  1670  	}
  1671  
  1672  	preparer := autorest.CreatePreparer(
  1673  		autorest.AsDelete(),
  1674  		autorest.WithBaseURL(client.BaseURI),
  1675  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections/{collectionName}", pathParameters),
  1676  		autorest.WithQueryParameters(queryParameters))
  1677  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1678  }
  1679  
  1680  // DeleteMongoDBCollectionSender sends the DeleteMongoDBCollection request. The method will close the
  1681  // http.Response Body if it receives an error.
  1682  func (client DatabaseAccountsClient) DeleteMongoDBCollectionSender(req *http.Request) (future DatabaseAccountsDeleteMongoDBCollectionFuture, err error) {
  1683  	var resp *http.Response
  1684  	future.FutureAPI = &azure.Future{}
  1685  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1686  	if err != nil {
  1687  		return
  1688  	}
  1689  	var azf azure.Future
  1690  	azf, err = azure.NewFutureFromResponse(resp)
  1691  	future.FutureAPI = &azf
  1692  	future.Result = future.result
  1693  	return
  1694  }
  1695  
  1696  // DeleteMongoDBCollectionResponder handles the response to the DeleteMongoDBCollection request. The method always
  1697  // closes the http.Response Body.
  1698  func (client DatabaseAccountsClient) DeleteMongoDBCollectionResponder(resp *http.Response) (result autorest.Response, err error) {
  1699  	err = autorest.Respond(
  1700  		resp,
  1701  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1702  		autorest.ByClosing())
  1703  	result.Response = resp
  1704  	return
  1705  }
  1706  
  1707  // DeleteMongoDBDatabase deletes an existing Azure Cosmos DB MongoDB database.
  1708  // Parameters:
  1709  // resourceGroupName - name of an Azure resource group.
  1710  // accountName - cosmos DB database account name.
  1711  // databaseName - cosmos DB database name.
  1712  func (client DatabaseAccountsClient) DeleteMongoDBDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result DatabaseAccountsDeleteMongoDBDatabaseFuture, err error) {
  1713  	if tracing.IsEnabled() {
  1714  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteMongoDBDatabase")
  1715  		defer func() {
  1716  			sc := -1
  1717  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1718  				sc = result.FutureAPI.Response().StatusCode
  1719  			}
  1720  			tracing.EndSpan(ctx, sc, err)
  1721  		}()
  1722  	}
  1723  	if err := validation.Validate([]validation.Validation{
  1724  		{TargetValue: resourceGroupName,
  1725  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1726  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1727  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1728  		{TargetValue: accountName,
  1729  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1730  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1731  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1732  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteMongoDBDatabase", err.Error())
  1733  	}
  1734  
  1735  	req, err := client.DeleteMongoDBDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  1736  	if err != nil {
  1737  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteMongoDBDatabase", nil, "Failure preparing request")
  1738  		return
  1739  	}
  1740  
  1741  	result, err = client.DeleteMongoDBDatabaseSender(req)
  1742  	if err != nil {
  1743  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteMongoDBDatabase", result.Response(), "Failure sending request")
  1744  		return
  1745  	}
  1746  
  1747  	return
  1748  }
  1749  
  1750  // DeleteMongoDBDatabasePreparer prepares the DeleteMongoDBDatabase request.
  1751  func (client DatabaseAccountsClient) DeleteMongoDBDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  1752  	pathParameters := map[string]interface{}{
  1753  		"accountName":       autorest.Encode("path", accountName),
  1754  		"databaseName":      autorest.Encode("path", databaseName),
  1755  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1756  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1757  	}
  1758  
  1759  	const APIVersion = "2015-04-08"
  1760  	queryParameters := map[string]interface{}{
  1761  		"api-version": APIVersion,
  1762  	}
  1763  
  1764  	preparer := autorest.CreatePreparer(
  1765  		autorest.AsDelete(),
  1766  		autorest.WithBaseURL(client.BaseURI),
  1767  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}", pathParameters),
  1768  		autorest.WithQueryParameters(queryParameters))
  1769  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1770  }
  1771  
  1772  // DeleteMongoDBDatabaseSender sends the DeleteMongoDBDatabase request. The method will close the
  1773  // http.Response Body if it receives an error.
  1774  func (client DatabaseAccountsClient) DeleteMongoDBDatabaseSender(req *http.Request) (future DatabaseAccountsDeleteMongoDBDatabaseFuture, err error) {
  1775  	var resp *http.Response
  1776  	future.FutureAPI = &azure.Future{}
  1777  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1778  	if err != nil {
  1779  		return
  1780  	}
  1781  	var azf azure.Future
  1782  	azf, err = azure.NewFutureFromResponse(resp)
  1783  	future.FutureAPI = &azf
  1784  	future.Result = future.result
  1785  	return
  1786  }
  1787  
  1788  // DeleteMongoDBDatabaseResponder handles the response to the DeleteMongoDBDatabase request. The method always
  1789  // closes the http.Response Body.
  1790  func (client DatabaseAccountsClient) DeleteMongoDBDatabaseResponder(resp *http.Response) (result autorest.Response, err error) {
  1791  	err = autorest.Respond(
  1792  		resp,
  1793  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1794  		autorest.ByClosing())
  1795  	result.Response = resp
  1796  	return
  1797  }
  1798  
  1799  // DeleteSQLContainer deletes an existing Azure Cosmos DB SQL container.
  1800  // Parameters:
  1801  // resourceGroupName - name of an Azure resource group.
  1802  // accountName - cosmos DB database account name.
  1803  // databaseName - cosmos DB database name.
  1804  // containerName - cosmos DB container name.
  1805  func (client DatabaseAccountsClient) DeleteSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result DatabaseAccountsDeleteSQLContainerFuture, err error) {
  1806  	if tracing.IsEnabled() {
  1807  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteSQLContainer")
  1808  		defer func() {
  1809  			sc := -1
  1810  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1811  				sc = result.FutureAPI.Response().StatusCode
  1812  			}
  1813  			tracing.EndSpan(ctx, sc, err)
  1814  		}()
  1815  	}
  1816  	if err := validation.Validate([]validation.Validation{
  1817  		{TargetValue: resourceGroupName,
  1818  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1819  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1820  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1821  		{TargetValue: accountName,
  1822  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1823  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1824  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1825  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteSQLContainer", err.Error())
  1826  	}
  1827  
  1828  	req, err := client.DeleteSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName)
  1829  	if err != nil {
  1830  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteSQLContainer", nil, "Failure preparing request")
  1831  		return
  1832  	}
  1833  
  1834  	result, err = client.DeleteSQLContainerSender(req)
  1835  	if err != nil {
  1836  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteSQLContainer", result.Response(), "Failure sending request")
  1837  		return
  1838  	}
  1839  
  1840  	return
  1841  }
  1842  
  1843  // DeleteSQLContainerPreparer prepares the DeleteSQLContainer request.
  1844  func (client DatabaseAccountsClient) DeleteSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) {
  1845  	pathParameters := map[string]interface{}{
  1846  		"accountName":       autorest.Encode("path", accountName),
  1847  		"containerName":     autorest.Encode("path", containerName),
  1848  		"databaseName":      autorest.Encode("path", databaseName),
  1849  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1850  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1851  	}
  1852  
  1853  	const APIVersion = "2015-04-08"
  1854  	queryParameters := map[string]interface{}{
  1855  		"api-version": APIVersion,
  1856  	}
  1857  
  1858  	preparer := autorest.CreatePreparer(
  1859  		autorest.AsDelete(),
  1860  		autorest.WithBaseURL(client.BaseURI),
  1861  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers/{containerName}", pathParameters),
  1862  		autorest.WithQueryParameters(queryParameters))
  1863  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1864  }
  1865  
  1866  // DeleteSQLContainerSender sends the DeleteSQLContainer request. The method will close the
  1867  // http.Response Body if it receives an error.
  1868  func (client DatabaseAccountsClient) DeleteSQLContainerSender(req *http.Request) (future DatabaseAccountsDeleteSQLContainerFuture, err error) {
  1869  	var resp *http.Response
  1870  	future.FutureAPI = &azure.Future{}
  1871  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1872  	if err != nil {
  1873  		return
  1874  	}
  1875  	var azf azure.Future
  1876  	azf, err = azure.NewFutureFromResponse(resp)
  1877  	future.FutureAPI = &azf
  1878  	future.Result = future.result
  1879  	return
  1880  }
  1881  
  1882  // DeleteSQLContainerResponder handles the response to the DeleteSQLContainer request. The method always
  1883  // closes the http.Response Body.
  1884  func (client DatabaseAccountsClient) DeleteSQLContainerResponder(resp *http.Response) (result autorest.Response, err error) {
  1885  	err = autorest.Respond(
  1886  		resp,
  1887  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1888  		autorest.ByClosing())
  1889  	result.Response = resp
  1890  	return
  1891  }
  1892  
  1893  // DeleteSQLDatabase deletes an existing Azure Cosmos DB SQL database.
  1894  // Parameters:
  1895  // resourceGroupName - name of an Azure resource group.
  1896  // accountName - cosmos DB database account name.
  1897  // databaseName - cosmos DB database name.
  1898  func (client DatabaseAccountsClient) DeleteSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result DatabaseAccountsDeleteSQLDatabaseFuture, err error) {
  1899  	if tracing.IsEnabled() {
  1900  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteSQLDatabase")
  1901  		defer func() {
  1902  			sc := -1
  1903  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1904  				sc = result.FutureAPI.Response().StatusCode
  1905  			}
  1906  			tracing.EndSpan(ctx, sc, err)
  1907  		}()
  1908  	}
  1909  	if err := validation.Validate([]validation.Validation{
  1910  		{TargetValue: resourceGroupName,
  1911  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1912  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1913  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1914  		{TargetValue: accountName,
  1915  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1916  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1917  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1918  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteSQLDatabase", err.Error())
  1919  	}
  1920  
  1921  	req, err := client.DeleteSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  1922  	if err != nil {
  1923  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteSQLDatabase", nil, "Failure preparing request")
  1924  		return
  1925  	}
  1926  
  1927  	result, err = client.DeleteSQLDatabaseSender(req)
  1928  	if err != nil {
  1929  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteSQLDatabase", result.Response(), "Failure sending request")
  1930  		return
  1931  	}
  1932  
  1933  	return
  1934  }
  1935  
  1936  // DeleteSQLDatabasePreparer prepares the DeleteSQLDatabase request.
  1937  func (client DatabaseAccountsClient) DeleteSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  1938  	pathParameters := map[string]interface{}{
  1939  		"accountName":       autorest.Encode("path", accountName),
  1940  		"databaseName":      autorest.Encode("path", databaseName),
  1941  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1942  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1943  	}
  1944  
  1945  	const APIVersion = "2015-04-08"
  1946  	queryParameters := map[string]interface{}{
  1947  		"api-version": APIVersion,
  1948  	}
  1949  
  1950  	preparer := autorest.CreatePreparer(
  1951  		autorest.AsDelete(),
  1952  		autorest.WithBaseURL(client.BaseURI),
  1953  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}", pathParameters),
  1954  		autorest.WithQueryParameters(queryParameters))
  1955  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1956  }
  1957  
  1958  // DeleteSQLDatabaseSender sends the DeleteSQLDatabase request. The method will close the
  1959  // http.Response Body if it receives an error.
  1960  func (client DatabaseAccountsClient) DeleteSQLDatabaseSender(req *http.Request) (future DatabaseAccountsDeleteSQLDatabaseFuture, err error) {
  1961  	var resp *http.Response
  1962  	future.FutureAPI = &azure.Future{}
  1963  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1964  	if err != nil {
  1965  		return
  1966  	}
  1967  	var azf azure.Future
  1968  	azf, err = azure.NewFutureFromResponse(resp)
  1969  	future.FutureAPI = &azf
  1970  	future.Result = future.result
  1971  	return
  1972  }
  1973  
  1974  // DeleteSQLDatabaseResponder handles the response to the DeleteSQLDatabase request. The method always
  1975  // closes the http.Response Body.
  1976  func (client DatabaseAccountsClient) DeleteSQLDatabaseResponder(resp *http.Response) (result autorest.Response, err error) {
  1977  	err = autorest.Respond(
  1978  		resp,
  1979  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1980  		autorest.ByClosing())
  1981  	result.Response = resp
  1982  	return
  1983  }
  1984  
  1985  // DeleteTable deletes an existing Azure Cosmos DB Table.
  1986  // Parameters:
  1987  // resourceGroupName - name of an Azure resource group.
  1988  // accountName - cosmos DB database account name.
  1989  // tableName - cosmos DB table name.
  1990  func (client DatabaseAccountsClient) DeleteTable(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result DatabaseAccountsDeleteTableFuture, err error) {
  1991  	if tracing.IsEnabled() {
  1992  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.DeleteTable")
  1993  		defer func() {
  1994  			sc := -1
  1995  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1996  				sc = result.FutureAPI.Response().StatusCode
  1997  			}
  1998  			tracing.EndSpan(ctx, sc, err)
  1999  		}()
  2000  	}
  2001  	if err := validation.Validate([]validation.Validation{
  2002  		{TargetValue: resourceGroupName,
  2003  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2004  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2005  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2006  		{TargetValue: accountName,
  2007  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2008  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2009  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2010  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "DeleteTable", err.Error())
  2011  	}
  2012  
  2013  	req, err := client.DeleteTablePreparer(ctx, resourceGroupName, accountName, tableName)
  2014  	if err != nil {
  2015  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteTable", nil, "Failure preparing request")
  2016  		return
  2017  	}
  2018  
  2019  	result, err = client.DeleteTableSender(req)
  2020  	if err != nil {
  2021  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "DeleteTable", result.Response(), "Failure sending request")
  2022  		return
  2023  	}
  2024  
  2025  	return
  2026  }
  2027  
  2028  // DeleteTablePreparer prepares the DeleteTable request.
  2029  func (client DatabaseAccountsClient) DeleteTablePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
  2030  	pathParameters := map[string]interface{}{
  2031  		"accountName":       autorest.Encode("path", accountName),
  2032  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2033  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2034  		"tableName":         autorest.Encode("path", tableName),
  2035  	}
  2036  
  2037  	const APIVersion = "2015-04-08"
  2038  	queryParameters := map[string]interface{}{
  2039  		"api-version": APIVersion,
  2040  	}
  2041  
  2042  	preparer := autorest.CreatePreparer(
  2043  		autorest.AsDelete(),
  2044  		autorest.WithBaseURL(client.BaseURI),
  2045  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables/{tableName}", pathParameters),
  2046  		autorest.WithQueryParameters(queryParameters))
  2047  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2048  }
  2049  
  2050  // DeleteTableSender sends the DeleteTable request. The method will close the
  2051  // http.Response Body if it receives an error.
  2052  func (client DatabaseAccountsClient) DeleteTableSender(req *http.Request) (future DatabaseAccountsDeleteTableFuture, err error) {
  2053  	var resp *http.Response
  2054  	future.FutureAPI = &azure.Future{}
  2055  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2056  	if err != nil {
  2057  		return
  2058  	}
  2059  	var azf azure.Future
  2060  	azf, err = azure.NewFutureFromResponse(resp)
  2061  	future.FutureAPI = &azf
  2062  	future.Result = future.result
  2063  	return
  2064  }
  2065  
  2066  // DeleteTableResponder handles the response to the DeleteTable request. The method always
  2067  // closes the http.Response Body.
  2068  func (client DatabaseAccountsClient) DeleteTableResponder(resp *http.Response) (result autorest.Response, err error) {
  2069  	err = autorest.Respond(
  2070  		resp,
  2071  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  2072  		autorest.ByClosing())
  2073  	result.Response = resp
  2074  	return
  2075  }
  2076  
  2077  // FailoverPriorityChange changes the failover priority for the Azure Cosmos DB database account. A failover priority
  2078  // of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover
  2079  // priority values must be unique for each of the regions in which the database account exists.
  2080  // Parameters:
  2081  // resourceGroupName - name of an Azure resource group.
  2082  // accountName - cosmos DB database account name.
  2083  // failoverParameters - the new failover policies for the database account.
  2084  func (client DatabaseAccountsClient) FailoverPriorityChange(ctx context.Context, resourceGroupName string, accountName string, failoverParameters FailoverPolicies) (result DatabaseAccountsFailoverPriorityChangeFuture, err error) {
  2085  	if tracing.IsEnabled() {
  2086  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.FailoverPriorityChange")
  2087  		defer func() {
  2088  			sc := -1
  2089  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  2090  				sc = result.FutureAPI.Response().StatusCode
  2091  			}
  2092  			tracing.EndSpan(ctx, sc, err)
  2093  		}()
  2094  	}
  2095  	if err := validation.Validate([]validation.Validation{
  2096  		{TargetValue: resourceGroupName,
  2097  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2098  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2099  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2100  		{TargetValue: accountName,
  2101  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2102  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2103  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  2104  		{TargetValue: failoverParameters,
  2105  			Constraints: []validation.Constraint{{Target: "failoverParameters.FailoverPolicies", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  2106  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "FailoverPriorityChange", err.Error())
  2107  	}
  2108  
  2109  	req, err := client.FailoverPriorityChangePreparer(ctx, resourceGroupName, accountName, failoverParameters)
  2110  	if err != nil {
  2111  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "FailoverPriorityChange", nil, "Failure preparing request")
  2112  		return
  2113  	}
  2114  
  2115  	result, err = client.FailoverPriorityChangeSender(req)
  2116  	if err != nil {
  2117  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "FailoverPriorityChange", result.Response(), "Failure sending request")
  2118  		return
  2119  	}
  2120  
  2121  	return
  2122  }
  2123  
  2124  // FailoverPriorityChangePreparer prepares the FailoverPriorityChange request.
  2125  func (client DatabaseAccountsClient) FailoverPriorityChangePreparer(ctx context.Context, resourceGroupName string, accountName string, failoverParameters FailoverPolicies) (*http.Request, error) {
  2126  	pathParameters := map[string]interface{}{
  2127  		"accountName":       autorest.Encode("path", accountName),
  2128  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2129  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2130  	}
  2131  
  2132  	const APIVersion = "2015-04-08"
  2133  	queryParameters := map[string]interface{}{
  2134  		"api-version": APIVersion,
  2135  	}
  2136  
  2137  	preparer := autorest.CreatePreparer(
  2138  		autorest.AsContentType("application/json; charset=utf-8"),
  2139  		autorest.AsPost(),
  2140  		autorest.WithBaseURL(client.BaseURI),
  2141  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/failoverPriorityChange", pathParameters),
  2142  		autorest.WithJSON(failoverParameters),
  2143  		autorest.WithQueryParameters(queryParameters))
  2144  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2145  }
  2146  
  2147  // FailoverPriorityChangeSender sends the FailoverPriorityChange request. The method will close the
  2148  // http.Response Body if it receives an error.
  2149  func (client DatabaseAccountsClient) FailoverPriorityChangeSender(req *http.Request) (future DatabaseAccountsFailoverPriorityChangeFuture, err error) {
  2150  	var resp *http.Response
  2151  	future.FutureAPI = &azure.Future{}
  2152  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2153  	if err != nil {
  2154  		return
  2155  	}
  2156  	var azf azure.Future
  2157  	azf, err = azure.NewFutureFromResponse(resp)
  2158  	future.FutureAPI = &azf
  2159  	future.Result = future.result
  2160  	return
  2161  }
  2162  
  2163  // FailoverPriorityChangeResponder handles the response to the FailoverPriorityChange request. The method always
  2164  // closes the http.Response Body.
  2165  func (client DatabaseAccountsClient) FailoverPriorityChangeResponder(resp *http.Response) (result autorest.Response, err error) {
  2166  	err = autorest.Respond(
  2167  		resp,
  2168  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  2169  		autorest.ByClosing())
  2170  	result.Response = resp
  2171  	return
  2172  }
  2173  
  2174  // Get retrieves the properties of an existing Azure Cosmos DB database account.
  2175  // Parameters:
  2176  // resourceGroupName - name of an Azure resource group.
  2177  // accountName - cosmos DB database account name.
  2178  func (client DatabaseAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccount, err error) {
  2179  	if tracing.IsEnabled() {
  2180  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Get")
  2181  		defer func() {
  2182  			sc := -1
  2183  			if result.Response.Response != nil {
  2184  				sc = result.Response.Response.StatusCode
  2185  			}
  2186  			tracing.EndSpan(ctx, sc, err)
  2187  		}()
  2188  	}
  2189  	if err := validation.Validate([]validation.Validation{
  2190  		{TargetValue: resourceGroupName,
  2191  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2192  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2193  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2194  		{TargetValue: accountName,
  2195  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2196  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2197  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2198  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Get", err.Error())
  2199  	}
  2200  
  2201  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
  2202  	if err != nil {
  2203  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", nil, "Failure preparing request")
  2204  		return
  2205  	}
  2206  
  2207  	resp, err := client.GetSender(req)
  2208  	if err != nil {
  2209  		result.Response = autorest.Response{Response: resp}
  2210  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", resp, "Failure sending request")
  2211  		return
  2212  	}
  2213  
  2214  	result, err = client.GetResponder(resp)
  2215  	if err != nil {
  2216  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", resp, "Failure responding to request")
  2217  		return
  2218  	}
  2219  
  2220  	return
  2221  }
  2222  
  2223  // GetPreparer prepares the Get request.
  2224  func (client DatabaseAccountsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  2225  	pathParameters := map[string]interface{}{
  2226  		"accountName":       autorest.Encode("path", accountName),
  2227  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2228  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2229  	}
  2230  
  2231  	const APIVersion = "2015-04-08"
  2232  	queryParameters := map[string]interface{}{
  2233  		"api-version": APIVersion,
  2234  	}
  2235  
  2236  	preparer := autorest.CreatePreparer(
  2237  		autorest.AsGet(),
  2238  		autorest.WithBaseURL(client.BaseURI),
  2239  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
  2240  		autorest.WithQueryParameters(queryParameters))
  2241  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2242  }
  2243  
  2244  // GetSender sends the Get request. The method will close the
  2245  // http.Response Body if it receives an error.
  2246  func (client DatabaseAccountsClient) GetSender(req *http.Request) (*http.Response, error) {
  2247  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2248  }
  2249  
  2250  // GetResponder handles the response to the Get request. The method always
  2251  // closes the http.Response Body.
  2252  func (client DatabaseAccountsClient) GetResponder(resp *http.Response) (result DatabaseAccount, err error) {
  2253  	err = autorest.Respond(
  2254  		resp,
  2255  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2256  		autorest.ByUnmarshallingJSON(&result),
  2257  		autorest.ByClosing())
  2258  	result.Response = autorest.Response{Response: resp}
  2259  	return
  2260  }
  2261  
  2262  // GetCassandraKeyspace gets the Cassandra keyspaces under an existing Azure Cosmos DB database account with the
  2263  // provided name.
  2264  // Parameters:
  2265  // resourceGroupName - name of an Azure resource group.
  2266  // accountName - cosmos DB database account name.
  2267  // keyspaceName - cosmos DB keyspace name.
  2268  func (client DatabaseAccountsClient) GetCassandraKeyspace(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result CassandraKeyspace, err error) {
  2269  	if tracing.IsEnabled() {
  2270  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetCassandraKeyspace")
  2271  		defer func() {
  2272  			sc := -1
  2273  			if result.Response.Response != nil {
  2274  				sc = result.Response.Response.StatusCode
  2275  			}
  2276  			tracing.EndSpan(ctx, sc, err)
  2277  		}()
  2278  	}
  2279  	if err := validation.Validate([]validation.Validation{
  2280  		{TargetValue: resourceGroupName,
  2281  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2282  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2283  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2284  		{TargetValue: accountName,
  2285  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2286  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2287  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2288  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetCassandraKeyspace", err.Error())
  2289  	}
  2290  
  2291  	req, err := client.GetCassandraKeyspacePreparer(ctx, resourceGroupName, accountName, keyspaceName)
  2292  	if err != nil {
  2293  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspace", nil, "Failure preparing request")
  2294  		return
  2295  	}
  2296  
  2297  	resp, err := client.GetCassandraKeyspaceSender(req)
  2298  	if err != nil {
  2299  		result.Response = autorest.Response{Response: resp}
  2300  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspace", resp, "Failure sending request")
  2301  		return
  2302  	}
  2303  
  2304  	result, err = client.GetCassandraKeyspaceResponder(resp)
  2305  	if err != nil {
  2306  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspace", resp, "Failure responding to request")
  2307  		return
  2308  	}
  2309  
  2310  	return
  2311  }
  2312  
  2313  // GetCassandraKeyspacePreparer prepares the GetCassandraKeyspace request.
  2314  func (client DatabaseAccountsClient) GetCassandraKeyspacePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
  2315  	pathParameters := map[string]interface{}{
  2316  		"accountName":       autorest.Encode("path", accountName),
  2317  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  2318  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2319  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2320  	}
  2321  
  2322  	const APIVersion = "2015-04-08"
  2323  	queryParameters := map[string]interface{}{
  2324  		"api-version": APIVersion,
  2325  	}
  2326  
  2327  	preparer := autorest.CreatePreparer(
  2328  		autorest.AsGet(),
  2329  		autorest.WithBaseURL(client.BaseURI),
  2330  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}", pathParameters),
  2331  		autorest.WithQueryParameters(queryParameters))
  2332  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2333  }
  2334  
  2335  // GetCassandraKeyspaceSender sends the GetCassandraKeyspace request. The method will close the
  2336  // http.Response Body if it receives an error.
  2337  func (client DatabaseAccountsClient) GetCassandraKeyspaceSender(req *http.Request) (*http.Response, error) {
  2338  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2339  }
  2340  
  2341  // GetCassandraKeyspaceResponder handles the response to the GetCassandraKeyspace request. The method always
  2342  // closes the http.Response Body.
  2343  func (client DatabaseAccountsClient) GetCassandraKeyspaceResponder(resp *http.Response) (result CassandraKeyspace, err error) {
  2344  	err = autorest.Respond(
  2345  		resp,
  2346  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2347  		autorest.ByUnmarshallingJSON(&result),
  2348  		autorest.ByClosing())
  2349  	result.Response = autorest.Response{Response: resp}
  2350  	return
  2351  }
  2352  
  2353  // GetCassandraKeyspaceThroughput gets the RUs per second of the Cassandra Keyspace under an existing Azure Cosmos DB
  2354  // database account with the provided name.
  2355  // Parameters:
  2356  // resourceGroupName - name of an Azure resource group.
  2357  // accountName - cosmos DB database account name.
  2358  // keyspaceName - cosmos DB keyspace name.
  2359  func (client DatabaseAccountsClient) GetCassandraKeyspaceThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result Throughput, err error) {
  2360  	if tracing.IsEnabled() {
  2361  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetCassandraKeyspaceThroughput")
  2362  		defer func() {
  2363  			sc := -1
  2364  			if result.Response.Response != nil {
  2365  				sc = result.Response.Response.StatusCode
  2366  			}
  2367  			tracing.EndSpan(ctx, sc, err)
  2368  		}()
  2369  	}
  2370  	if err := validation.Validate([]validation.Validation{
  2371  		{TargetValue: resourceGroupName,
  2372  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2373  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2374  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2375  		{TargetValue: accountName,
  2376  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2377  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2378  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2379  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetCassandraKeyspaceThroughput", err.Error())
  2380  	}
  2381  
  2382  	req, err := client.GetCassandraKeyspaceThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName)
  2383  	if err != nil {
  2384  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspaceThroughput", nil, "Failure preparing request")
  2385  		return
  2386  	}
  2387  
  2388  	resp, err := client.GetCassandraKeyspaceThroughputSender(req)
  2389  	if err != nil {
  2390  		result.Response = autorest.Response{Response: resp}
  2391  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspaceThroughput", resp, "Failure sending request")
  2392  		return
  2393  	}
  2394  
  2395  	result, err = client.GetCassandraKeyspaceThroughputResponder(resp)
  2396  	if err != nil {
  2397  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraKeyspaceThroughput", resp, "Failure responding to request")
  2398  		return
  2399  	}
  2400  
  2401  	return
  2402  }
  2403  
  2404  // GetCassandraKeyspaceThroughputPreparer prepares the GetCassandraKeyspaceThroughput request.
  2405  func (client DatabaseAccountsClient) GetCassandraKeyspaceThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
  2406  	pathParameters := map[string]interface{}{
  2407  		"accountName":       autorest.Encode("path", accountName),
  2408  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  2409  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2410  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2411  	}
  2412  
  2413  	const APIVersion = "2015-04-08"
  2414  	queryParameters := map[string]interface{}{
  2415  		"api-version": APIVersion,
  2416  	}
  2417  
  2418  	preparer := autorest.CreatePreparer(
  2419  		autorest.AsGet(),
  2420  		autorest.WithBaseURL(client.BaseURI),
  2421  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/settings/throughput", pathParameters),
  2422  		autorest.WithQueryParameters(queryParameters))
  2423  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2424  }
  2425  
  2426  // GetCassandraKeyspaceThroughputSender sends the GetCassandraKeyspaceThroughput request. The method will close the
  2427  // http.Response Body if it receives an error.
  2428  func (client DatabaseAccountsClient) GetCassandraKeyspaceThroughputSender(req *http.Request) (*http.Response, error) {
  2429  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2430  }
  2431  
  2432  // GetCassandraKeyspaceThroughputResponder handles the response to the GetCassandraKeyspaceThroughput request. The method always
  2433  // closes the http.Response Body.
  2434  func (client DatabaseAccountsClient) GetCassandraKeyspaceThroughputResponder(resp *http.Response) (result Throughput, err error) {
  2435  	err = autorest.Respond(
  2436  		resp,
  2437  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2438  		autorest.ByUnmarshallingJSON(&result),
  2439  		autorest.ByClosing())
  2440  	result.Response = autorest.Response{Response: resp}
  2441  	return
  2442  }
  2443  
  2444  // GetCassandraTable gets the Cassandra table under an existing Azure Cosmos DB database account.
  2445  // Parameters:
  2446  // resourceGroupName - name of an Azure resource group.
  2447  // accountName - cosmos DB database account name.
  2448  // keyspaceName - cosmos DB keyspace name.
  2449  // tableName - cosmos DB table name.
  2450  func (client DatabaseAccountsClient) GetCassandraTable(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result CassandraTable, err error) {
  2451  	if tracing.IsEnabled() {
  2452  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetCassandraTable")
  2453  		defer func() {
  2454  			sc := -1
  2455  			if result.Response.Response != nil {
  2456  				sc = result.Response.Response.StatusCode
  2457  			}
  2458  			tracing.EndSpan(ctx, sc, err)
  2459  		}()
  2460  	}
  2461  	if err := validation.Validate([]validation.Validation{
  2462  		{TargetValue: resourceGroupName,
  2463  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2464  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2465  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2466  		{TargetValue: accountName,
  2467  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2468  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2469  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2470  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetCassandraTable", err.Error())
  2471  	}
  2472  
  2473  	req, err := client.GetCassandraTablePreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
  2474  	if err != nil {
  2475  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTable", nil, "Failure preparing request")
  2476  		return
  2477  	}
  2478  
  2479  	resp, err := client.GetCassandraTableSender(req)
  2480  	if err != nil {
  2481  		result.Response = autorest.Response{Response: resp}
  2482  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTable", resp, "Failure sending request")
  2483  		return
  2484  	}
  2485  
  2486  	result, err = client.GetCassandraTableResponder(resp)
  2487  	if err != nil {
  2488  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTable", resp, "Failure responding to request")
  2489  		return
  2490  	}
  2491  
  2492  	return
  2493  }
  2494  
  2495  // GetCassandraTablePreparer prepares the GetCassandraTable request.
  2496  func (client DatabaseAccountsClient) GetCassandraTablePreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
  2497  	pathParameters := map[string]interface{}{
  2498  		"accountName":       autorest.Encode("path", accountName),
  2499  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  2500  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2501  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2502  		"tableName":         autorest.Encode("path", tableName),
  2503  	}
  2504  
  2505  	const APIVersion = "2015-04-08"
  2506  	queryParameters := map[string]interface{}{
  2507  		"api-version": APIVersion,
  2508  	}
  2509  
  2510  	preparer := autorest.CreatePreparer(
  2511  		autorest.AsGet(),
  2512  		autorest.WithBaseURL(client.BaseURI),
  2513  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables/{tableName}", pathParameters),
  2514  		autorest.WithQueryParameters(queryParameters))
  2515  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2516  }
  2517  
  2518  // GetCassandraTableSender sends the GetCassandraTable request. The method will close the
  2519  // http.Response Body if it receives an error.
  2520  func (client DatabaseAccountsClient) GetCassandraTableSender(req *http.Request) (*http.Response, error) {
  2521  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2522  }
  2523  
  2524  // GetCassandraTableResponder handles the response to the GetCassandraTable request. The method always
  2525  // closes the http.Response Body.
  2526  func (client DatabaseAccountsClient) GetCassandraTableResponder(resp *http.Response) (result CassandraTable, err error) {
  2527  	err = autorest.Respond(
  2528  		resp,
  2529  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2530  		autorest.ByUnmarshallingJSON(&result),
  2531  		autorest.ByClosing())
  2532  	result.Response = autorest.Response{Response: resp}
  2533  	return
  2534  }
  2535  
  2536  // GetCassandraTableThroughput gets the RUs per second of the Cassandra table under an existing Azure Cosmos DB
  2537  // database account with the provided name.
  2538  // Parameters:
  2539  // resourceGroupName - name of an Azure resource group.
  2540  // accountName - cosmos DB database account name.
  2541  // keyspaceName - cosmos DB keyspace name.
  2542  // tableName - cosmos DB table name.
  2543  func (client DatabaseAccountsClient) GetCassandraTableThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (result Throughput, err error) {
  2544  	if tracing.IsEnabled() {
  2545  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetCassandraTableThroughput")
  2546  		defer func() {
  2547  			sc := -1
  2548  			if result.Response.Response != nil {
  2549  				sc = result.Response.Response.StatusCode
  2550  			}
  2551  			tracing.EndSpan(ctx, sc, err)
  2552  		}()
  2553  	}
  2554  	if err := validation.Validate([]validation.Validation{
  2555  		{TargetValue: resourceGroupName,
  2556  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2557  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2558  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2559  		{TargetValue: accountName,
  2560  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2561  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2562  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2563  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetCassandraTableThroughput", err.Error())
  2564  	}
  2565  
  2566  	req, err := client.GetCassandraTableThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName)
  2567  	if err != nil {
  2568  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTableThroughput", nil, "Failure preparing request")
  2569  		return
  2570  	}
  2571  
  2572  	resp, err := client.GetCassandraTableThroughputSender(req)
  2573  	if err != nil {
  2574  		result.Response = autorest.Response{Response: resp}
  2575  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTableThroughput", resp, "Failure sending request")
  2576  		return
  2577  	}
  2578  
  2579  	result, err = client.GetCassandraTableThroughputResponder(resp)
  2580  	if err != nil {
  2581  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetCassandraTableThroughput", resp, "Failure responding to request")
  2582  		return
  2583  	}
  2584  
  2585  	return
  2586  }
  2587  
  2588  // GetCassandraTableThroughputPreparer prepares the GetCassandraTableThroughput request.
  2589  func (client DatabaseAccountsClient) GetCassandraTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string) (*http.Request, error) {
  2590  	pathParameters := map[string]interface{}{
  2591  		"accountName":       autorest.Encode("path", accountName),
  2592  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  2593  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2594  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2595  		"tableName":         autorest.Encode("path", tableName),
  2596  	}
  2597  
  2598  	const APIVersion = "2015-04-08"
  2599  	queryParameters := map[string]interface{}{
  2600  		"api-version": APIVersion,
  2601  	}
  2602  
  2603  	preparer := autorest.CreatePreparer(
  2604  		autorest.AsGet(),
  2605  		autorest.WithBaseURL(client.BaseURI),
  2606  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables/{tableName}/settings/throughput", pathParameters),
  2607  		autorest.WithQueryParameters(queryParameters))
  2608  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2609  }
  2610  
  2611  // GetCassandraTableThroughputSender sends the GetCassandraTableThroughput request. The method will close the
  2612  // http.Response Body if it receives an error.
  2613  func (client DatabaseAccountsClient) GetCassandraTableThroughputSender(req *http.Request) (*http.Response, error) {
  2614  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2615  }
  2616  
  2617  // GetCassandraTableThroughputResponder handles the response to the GetCassandraTableThroughput request. The method always
  2618  // closes the http.Response Body.
  2619  func (client DatabaseAccountsClient) GetCassandraTableThroughputResponder(resp *http.Response) (result Throughput, err error) {
  2620  	err = autorest.Respond(
  2621  		resp,
  2622  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2623  		autorest.ByUnmarshallingJSON(&result),
  2624  		autorest.ByClosing())
  2625  	result.Response = autorest.Response{Response: resp}
  2626  	return
  2627  }
  2628  
  2629  // GetGremlinDatabase gets the Gremlin databases under an existing Azure Cosmos DB database account with the provided
  2630  // name.
  2631  // Parameters:
  2632  // resourceGroupName - name of an Azure resource group.
  2633  // accountName - cosmos DB database account name.
  2634  // databaseName - cosmos DB database name.
  2635  func (client DatabaseAccountsClient) GetGremlinDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result GremlinDatabase, err error) {
  2636  	if tracing.IsEnabled() {
  2637  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetGremlinDatabase")
  2638  		defer func() {
  2639  			sc := -1
  2640  			if result.Response.Response != nil {
  2641  				sc = result.Response.Response.StatusCode
  2642  			}
  2643  			tracing.EndSpan(ctx, sc, err)
  2644  		}()
  2645  	}
  2646  	if err := validation.Validate([]validation.Validation{
  2647  		{TargetValue: resourceGroupName,
  2648  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2649  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2650  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2651  		{TargetValue: accountName,
  2652  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2653  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2654  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2655  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetGremlinDatabase", err.Error())
  2656  	}
  2657  
  2658  	req, err := client.GetGremlinDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  2659  	if err != nil {
  2660  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabase", nil, "Failure preparing request")
  2661  		return
  2662  	}
  2663  
  2664  	resp, err := client.GetGremlinDatabaseSender(req)
  2665  	if err != nil {
  2666  		result.Response = autorest.Response{Response: resp}
  2667  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabase", resp, "Failure sending request")
  2668  		return
  2669  	}
  2670  
  2671  	result, err = client.GetGremlinDatabaseResponder(resp)
  2672  	if err != nil {
  2673  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabase", resp, "Failure responding to request")
  2674  		return
  2675  	}
  2676  
  2677  	return
  2678  }
  2679  
  2680  // GetGremlinDatabasePreparer prepares the GetGremlinDatabase request.
  2681  func (client DatabaseAccountsClient) GetGremlinDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  2682  	pathParameters := map[string]interface{}{
  2683  		"accountName":       autorest.Encode("path", accountName),
  2684  		"databaseName":      autorest.Encode("path", databaseName),
  2685  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2686  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2687  	}
  2688  
  2689  	const APIVersion = "2015-04-08"
  2690  	queryParameters := map[string]interface{}{
  2691  		"api-version": APIVersion,
  2692  	}
  2693  
  2694  	preparer := autorest.CreatePreparer(
  2695  		autorest.AsGet(),
  2696  		autorest.WithBaseURL(client.BaseURI),
  2697  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}", pathParameters),
  2698  		autorest.WithQueryParameters(queryParameters))
  2699  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2700  }
  2701  
  2702  // GetGremlinDatabaseSender sends the GetGremlinDatabase request. The method will close the
  2703  // http.Response Body if it receives an error.
  2704  func (client DatabaseAccountsClient) GetGremlinDatabaseSender(req *http.Request) (*http.Response, error) {
  2705  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2706  }
  2707  
  2708  // GetGremlinDatabaseResponder handles the response to the GetGremlinDatabase request. The method always
  2709  // closes the http.Response Body.
  2710  func (client DatabaseAccountsClient) GetGremlinDatabaseResponder(resp *http.Response) (result GremlinDatabase, err error) {
  2711  	err = autorest.Respond(
  2712  		resp,
  2713  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2714  		autorest.ByUnmarshallingJSON(&result),
  2715  		autorest.ByClosing())
  2716  	result.Response = autorest.Response{Response: resp}
  2717  	return
  2718  }
  2719  
  2720  // GetGremlinDatabaseThroughput gets the RUs per second of the Gremlin database under an existing Azure Cosmos DB
  2721  // database account with the provided name.
  2722  // Parameters:
  2723  // resourceGroupName - name of an Azure resource group.
  2724  // accountName - cosmos DB database account name.
  2725  // databaseName - cosmos DB database name.
  2726  func (client DatabaseAccountsClient) GetGremlinDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result Throughput, err error) {
  2727  	if tracing.IsEnabled() {
  2728  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetGremlinDatabaseThroughput")
  2729  		defer func() {
  2730  			sc := -1
  2731  			if result.Response.Response != nil {
  2732  				sc = result.Response.Response.StatusCode
  2733  			}
  2734  			tracing.EndSpan(ctx, sc, err)
  2735  		}()
  2736  	}
  2737  	if err := validation.Validate([]validation.Validation{
  2738  		{TargetValue: resourceGroupName,
  2739  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2740  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2741  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2742  		{TargetValue: accountName,
  2743  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2744  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2745  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2746  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetGremlinDatabaseThroughput", err.Error())
  2747  	}
  2748  
  2749  	req, err := client.GetGremlinDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName)
  2750  	if err != nil {
  2751  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabaseThroughput", nil, "Failure preparing request")
  2752  		return
  2753  	}
  2754  
  2755  	resp, err := client.GetGremlinDatabaseThroughputSender(req)
  2756  	if err != nil {
  2757  		result.Response = autorest.Response{Response: resp}
  2758  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabaseThroughput", resp, "Failure sending request")
  2759  		return
  2760  	}
  2761  
  2762  	result, err = client.GetGremlinDatabaseThroughputResponder(resp)
  2763  	if err != nil {
  2764  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinDatabaseThroughput", resp, "Failure responding to request")
  2765  		return
  2766  	}
  2767  
  2768  	return
  2769  }
  2770  
  2771  // GetGremlinDatabaseThroughputPreparer prepares the GetGremlinDatabaseThroughput request.
  2772  func (client DatabaseAccountsClient) GetGremlinDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  2773  	pathParameters := map[string]interface{}{
  2774  		"accountName":       autorest.Encode("path", accountName),
  2775  		"databaseName":      autorest.Encode("path", databaseName),
  2776  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2777  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2778  	}
  2779  
  2780  	const APIVersion = "2015-04-08"
  2781  	queryParameters := map[string]interface{}{
  2782  		"api-version": APIVersion,
  2783  	}
  2784  
  2785  	preparer := autorest.CreatePreparer(
  2786  		autorest.AsGet(),
  2787  		autorest.WithBaseURL(client.BaseURI),
  2788  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/settings/throughput", pathParameters),
  2789  		autorest.WithQueryParameters(queryParameters))
  2790  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2791  }
  2792  
  2793  // GetGremlinDatabaseThroughputSender sends the GetGremlinDatabaseThroughput request. The method will close the
  2794  // http.Response Body if it receives an error.
  2795  func (client DatabaseAccountsClient) GetGremlinDatabaseThroughputSender(req *http.Request) (*http.Response, error) {
  2796  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2797  }
  2798  
  2799  // GetGremlinDatabaseThroughputResponder handles the response to the GetGremlinDatabaseThroughput request. The method always
  2800  // closes the http.Response Body.
  2801  func (client DatabaseAccountsClient) GetGremlinDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  2802  	err = autorest.Respond(
  2803  		resp,
  2804  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2805  		autorest.ByUnmarshallingJSON(&result),
  2806  		autorest.ByClosing())
  2807  	result.Response = autorest.Response{Response: resp}
  2808  	return
  2809  }
  2810  
  2811  // GetGremlinGraph gets the Gremlin graph under an existing Azure Cosmos DB database account.
  2812  // Parameters:
  2813  // resourceGroupName - name of an Azure resource group.
  2814  // accountName - cosmos DB database account name.
  2815  // databaseName - cosmos DB database name.
  2816  // graphName - cosmos DB graph name.
  2817  func (client DatabaseAccountsClient) GetGremlinGraph(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (result GremlinGraph, err error) {
  2818  	if tracing.IsEnabled() {
  2819  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetGremlinGraph")
  2820  		defer func() {
  2821  			sc := -1
  2822  			if result.Response.Response != nil {
  2823  				sc = result.Response.Response.StatusCode
  2824  			}
  2825  			tracing.EndSpan(ctx, sc, err)
  2826  		}()
  2827  	}
  2828  	if err := validation.Validate([]validation.Validation{
  2829  		{TargetValue: resourceGroupName,
  2830  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2831  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2832  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2833  		{TargetValue: accountName,
  2834  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2835  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2836  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2837  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetGremlinGraph", err.Error())
  2838  	}
  2839  
  2840  	req, err := client.GetGremlinGraphPreparer(ctx, resourceGroupName, accountName, databaseName, graphName)
  2841  	if err != nil {
  2842  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraph", nil, "Failure preparing request")
  2843  		return
  2844  	}
  2845  
  2846  	resp, err := client.GetGremlinGraphSender(req)
  2847  	if err != nil {
  2848  		result.Response = autorest.Response{Response: resp}
  2849  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraph", resp, "Failure sending request")
  2850  		return
  2851  	}
  2852  
  2853  	result, err = client.GetGremlinGraphResponder(resp)
  2854  	if err != nil {
  2855  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraph", resp, "Failure responding to request")
  2856  		return
  2857  	}
  2858  
  2859  	return
  2860  }
  2861  
  2862  // GetGremlinGraphPreparer prepares the GetGremlinGraph request.
  2863  func (client DatabaseAccountsClient) GetGremlinGraphPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (*http.Request, error) {
  2864  	pathParameters := map[string]interface{}{
  2865  		"accountName":       autorest.Encode("path", accountName),
  2866  		"databaseName":      autorest.Encode("path", databaseName),
  2867  		"graphName":         autorest.Encode("path", graphName),
  2868  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2869  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2870  	}
  2871  
  2872  	const APIVersion = "2015-04-08"
  2873  	queryParameters := map[string]interface{}{
  2874  		"api-version": APIVersion,
  2875  	}
  2876  
  2877  	preparer := autorest.CreatePreparer(
  2878  		autorest.AsGet(),
  2879  		autorest.WithBaseURL(client.BaseURI),
  2880  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs/{graphName}", pathParameters),
  2881  		autorest.WithQueryParameters(queryParameters))
  2882  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2883  }
  2884  
  2885  // GetGremlinGraphSender sends the GetGremlinGraph request. The method will close the
  2886  // http.Response Body if it receives an error.
  2887  func (client DatabaseAccountsClient) GetGremlinGraphSender(req *http.Request) (*http.Response, error) {
  2888  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2889  }
  2890  
  2891  // GetGremlinGraphResponder handles the response to the GetGremlinGraph request. The method always
  2892  // closes the http.Response Body.
  2893  func (client DatabaseAccountsClient) GetGremlinGraphResponder(resp *http.Response) (result GremlinGraph, err error) {
  2894  	err = autorest.Respond(
  2895  		resp,
  2896  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2897  		autorest.ByUnmarshallingJSON(&result),
  2898  		autorest.ByClosing())
  2899  	result.Response = autorest.Response{Response: resp}
  2900  	return
  2901  }
  2902  
  2903  // GetGremlinGraphThroughput gets the Gremlin graph throughput under an existing Azure Cosmos DB database account with
  2904  // the provided name.
  2905  // Parameters:
  2906  // resourceGroupName - name of an Azure resource group.
  2907  // accountName - cosmos DB database account name.
  2908  // databaseName - cosmos DB database name.
  2909  // graphName - cosmos DB graph name.
  2910  func (client DatabaseAccountsClient) GetGremlinGraphThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (result Throughput, err error) {
  2911  	if tracing.IsEnabled() {
  2912  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetGremlinGraphThroughput")
  2913  		defer func() {
  2914  			sc := -1
  2915  			if result.Response.Response != nil {
  2916  				sc = result.Response.Response.StatusCode
  2917  			}
  2918  			tracing.EndSpan(ctx, sc, err)
  2919  		}()
  2920  	}
  2921  	if err := validation.Validate([]validation.Validation{
  2922  		{TargetValue: resourceGroupName,
  2923  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  2924  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  2925  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  2926  		{TargetValue: accountName,
  2927  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  2928  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  2929  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  2930  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetGremlinGraphThroughput", err.Error())
  2931  	}
  2932  
  2933  	req, err := client.GetGremlinGraphThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, graphName)
  2934  	if err != nil {
  2935  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraphThroughput", nil, "Failure preparing request")
  2936  		return
  2937  	}
  2938  
  2939  	resp, err := client.GetGremlinGraphThroughputSender(req)
  2940  	if err != nil {
  2941  		result.Response = autorest.Response{Response: resp}
  2942  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraphThroughput", resp, "Failure sending request")
  2943  		return
  2944  	}
  2945  
  2946  	result, err = client.GetGremlinGraphThroughputResponder(resp)
  2947  	if err != nil {
  2948  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetGremlinGraphThroughput", resp, "Failure responding to request")
  2949  		return
  2950  	}
  2951  
  2952  	return
  2953  }
  2954  
  2955  // GetGremlinGraphThroughputPreparer prepares the GetGremlinGraphThroughput request.
  2956  func (client DatabaseAccountsClient) GetGremlinGraphThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string) (*http.Request, error) {
  2957  	pathParameters := map[string]interface{}{
  2958  		"accountName":       autorest.Encode("path", accountName),
  2959  		"databaseName":      autorest.Encode("path", databaseName),
  2960  		"graphName":         autorest.Encode("path", graphName),
  2961  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  2962  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  2963  	}
  2964  
  2965  	const APIVersion = "2015-04-08"
  2966  	queryParameters := map[string]interface{}{
  2967  		"api-version": APIVersion,
  2968  	}
  2969  
  2970  	preparer := autorest.CreatePreparer(
  2971  		autorest.AsGet(),
  2972  		autorest.WithBaseURL(client.BaseURI),
  2973  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs/{graphName}/settings/throughput", pathParameters),
  2974  		autorest.WithQueryParameters(queryParameters))
  2975  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2976  }
  2977  
  2978  // GetGremlinGraphThroughputSender sends the GetGremlinGraphThroughput request. The method will close the
  2979  // http.Response Body if it receives an error.
  2980  func (client DatabaseAccountsClient) GetGremlinGraphThroughputSender(req *http.Request) (*http.Response, error) {
  2981  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  2982  }
  2983  
  2984  // GetGremlinGraphThroughputResponder handles the response to the GetGremlinGraphThroughput request. The method always
  2985  // closes the http.Response Body.
  2986  func (client DatabaseAccountsClient) GetGremlinGraphThroughputResponder(resp *http.Response) (result Throughput, err error) {
  2987  	err = autorest.Respond(
  2988  		resp,
  2989  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2990  		autorest.ByUnmarshallingJSON(&result),
  2991  		autorest.ByClosing())
  2992  	result.Response = autorest.Response{Response: resp}
  2993  	return
  2994  }
  2995  
  2996  // GetMongoDBCollection gets the MongoDB collection under an existing Azure Cosmos DB database account.
  2997  // Parameters:
  2998  // resourceGroupName - name of an Azure resource group.
  2999  // accountName - cosmos DB database account name.
  3000  // databaseName - cosmos DB database name.
  3001  // collectionName - cosmos DB collection name.
  3002  func (client DatabaseAccountsClient) GetMongoDBCollection(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (result MongoDBCollection, err error) {
  3003  	if tracing.IsEnabled() {
  3004  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetMongoDBCollection")
  3005  		defer func() {
  3006  			sc := -1
  3007  			if result.Response.Response != nil {
  3008  				sc = result.Response.Response.StatusCode
  3009  			}
  3010  			tracing.EndSpan(ctx, sc, err)
  3011  		}()
  3012  	}
  3013  	if err := validation.Validate([]validation.Validation{
  3014  		{TargetValue: resourceGroupName,
  3015  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3016  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3017  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3018  		{TargetValue: accountName,
  3019  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3020  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3021  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3022  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetMongoDBCollection", err.Error())
  3023  	}
  3024  
  3025  	req, err := client.GetMongoDBCollectionPreparer(ctx, resourceGroupName, accountName, databaseName, collectionName)
  3026  	if err != nil {
  3027  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollection", nil, "Failure preparing request")
  3028  		return
  3029  	}
  3030  
  3031  	resp, err := client.GetMongoDBCollectionSender(req)
  3032  	if err != nil {
  3033  		result.Response = autorest.Response{Response: resp}
  3034  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollection", resp, "Failure sending request")
  3035  		return
  3036  	}
  3037  
  3038  	result, err = client.GetMongoDBCollectionResponder(resp)
  3039  	if err != nil {
  3040  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollection", resp, "Failure responding to request")
  3041  		return
  3042  	}
  3043  
  3044  	return
  3045  }
  3046  
  3047  // GetMongoDBCollectionPreparer prepares the GetMongoDBCollection request.
  3048  func (client DatabaseAccountsClient) GetMongoDBCollectionPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (*http.Request, error) {
  3049  	pathParameters := map[string]interface{}{
  3050  		"accountName":       autorest.Encode("path", accountName),
  3051  		"collectionName":    autorest.Encode("path", collectionName),
  3052  		"databaseName":      autorest.Encode("path", databaseName),
  3053  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3054  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3055  	}
  3056  
  3057  	const APIVersion = "2015-04-08"
  3058  	queryParameters := map[string]interface{}{
  3059  		"api-version": APIVersion,
  3060  	}
  3061  
  3062  	preparer := autorest.CreatePreparer(
  3063  		autorest.AsGet(),
  3064  		autorest.WithBaseURL(client.BaseURI),
  3065  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections/{collectionName}", pathParameters),
  3066  		autorest.WithQueryParameters(queryParameters))
  3067  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3068  }
  3069  
  3070  // GetMongoDBCollectionSender sends the GetMongoDBCollection request. The method will close the
  3071  // http.Response Body if it receives an error.
  3072  func (client DatabaseAccountsClient) GetMongoDBCollectionSender(req *http.Request) (*http.Response, error) {
  3073  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3074  }
  3075  
  3076  // GetMongoDBCollectionResponder handles the response to the GetMongoDBCollection request. The method always
  3077  // closes the http.Response Body.
  3078  func (client DatabaseAccountsClient) GetMongoDBCollectionResponder(resp *http.Response) (result MongoDBCollection, err error) {
  3079  	err = autorest.Respond(
  3080  		resp,
  3081  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3082  		autorest.ByUnmarshallingJSON(&result),
  3083  		autorest.ByClosing())
  3084  	result.Response = autorest.Response{Response: resp}
  3085  	return
  3086  }
  3087  
  3088  // GetMongoDBCollectionThroughput gets the RUs per second of the MongoDB collection under an existing Azure Cosmos DB
  3089  // database account with the provided name.
  3090  // Parameters:
  3091  // resourceGroupName - name of an Azure resource group.
  3092  // accountName - cosmos DB database account name.
  3093  // databaseName - cosmos DB database name.
  3094  // collectionName - cosmos DB collection name.
  3095  func (client DatabaseAccountsClient) GetMongoDBCollectionThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (result Throughput, err error) {
  3096  	if tracing.IsEnabled() {
  3097  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetMongoDBCollectionThroughput")
  3098  		defer func() {
  3099  			sc := -1
  3100  			if result.Response.Response != nil {
  3101  				sc = result.Response.Response.StatusCode
  3102  			}
  3103  			tracing.EndSpan(ctx, sc, err)
  3104  		}()
  3105  	}
  3106  	if err := validation.Validate([]validation.Validation{
  3107  		{TargetValue: resourceGroupName,
  3108  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3109  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3110  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3111  		{TargetValue: accountName,
  3112  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3113  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3114  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3115  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetMongoDBCollectionThroughput", err.Error())
  3116  	}
  3117  
  3118  	req, err := client.GetMongoDBCollectionThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, collectionName)
  3119  	if err != nil {
  3120  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollectionThroughput", nil, "Failure preparing request")
  3121  		return
  3122  	}
  3123  
  3124  	resp, err := client.GetMongoDBCollectionThroughputSender(req)
  3125  	if err != nil {
  3126  		result.Response = autorest.Response{Response: resp}
  3127  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollectionThroughput", resp, "Failure sending request")
  3128  		return
  3129  	}
  3130  
  3131  	result, err = client.GetMongoDBCollectionThroughputResponder(resp)
  3132  	if err != nil {
  3133  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBCollectionThroughput", resp, "Failure responding to request")
  3134  		return
  3135  	}
  3136  
  3137  	return
  3138  }
  3139  
  3140  // GetMongoDBCollectionThroughputPreparer prepares the GetMongoDBCollectionThroughput request.
  3141  func (client DatabaseAccountsClient) GetMongoDBCollectionThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string) (*http.Request, error) {
  3142  	pathParameters := map[string]interface{}{
  3143  		"accountName":       autorest.Encode("path", accountName),
  3144  		"collectionName":    autorest.Encode("path", collectionName),
  3145  		"databaseName":      autorest.Encode("path", databaseName),
  3146  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3147  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3148  	}
  3149  
  3150  	const APIVersion = "2015-04-08"
  3151  	queryParameters := map[string]interface{}{
  3152  		"api-version": APIVersion,
  3153  	}
  3154  
  3155  	preparer := autorest.CreatePreparer(
  3156  		autorest.AsGet(),
  3157  		autorest.WithBaseURL(client.BaseURI),
  3158  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections/{collectionName}/settings/throughput", pathParameters),
  3159  		autorest.WithQueryParameters(queryParameters))
  3160  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3161  }
  3162  
  3163  // GetMongoDBCollectionThroughputSender sends the GetMongoDBCollectionThroughput request. The method will close the
  3164  // http.Response Body if it receives an error.
  3165  func (client DatabaseAccountsClient) GetMongoDBCollectionThroughputSender(req *http.Request) (*http.Response, error) {
  3166  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3167  }
  3168  
  3169  // GetMongoDBCollectionThroughputResponder handles the response to the GetMongoDBCollectionThroughput request. The method always
  3170  // closes the http.Response Body.
  3171  func (client DatabaseAccountsClient) GetMongoDBCollectionThroughputResponder(resp *http.Response) (result Throughput, err error) {
  3172  	err = autorest.Respond(
  3173  		resp,
  3174  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3175  		autorest.ByUnmarshallingJSON(&result),
  3176  		autorest.ByClosing())
  3177  	result.Response = autorest.Response{Response: resp}
  3178  	return
  3179  }
  3180  
  3181  // GetMongoDBDatabase gets the MongoDB databases under an existing Azure Cosmos DB database account with the provided
  3182  // name.
  3183  // Parameters:
  3184  // resourceGroupName - name of an Azure resource group.
  3185  // accountName - cosmos DB database account name.
  3186  // databaseName - cosmos DB database name.
  3187  func (client DatabaseAccountsClient) GetMongoDBDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result MongoDBDatabase, err error) {
  3188  	if tracing.IsEnabled() {
  3189  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetMongoDBDatabase")
  3190  		defer func() {
  3191  			sc := -1
  3192  			if result.Response.Response != nil {
  3193  				sc = result.Response.Response.StatusCode
  3194  			}
  3195  			tracing.EndSpan(ctx, sc, err)
  3196  		}()
  3197  	}
  3198  	if err := validation.Validate([]validation.Validation{
  3199  		{TargetValue: resourceGroupName,
  3200  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3201  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3202  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3203  		{TargetValue: accountName,
  3204  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3205  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3206  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3207  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetMongoDBDatabase", err.Error())
  3208  	}
  3209  
  3210  	req, err := client.GetMongoDBDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  3211  	if err != nil {
  3212  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabase", nil, "Failure preparing request")
  3213  		return
  3214  	}
  3215  
  3216  	resp, err := client.GetMongoDBDatabaseSender(req)
  3217  	if err != nil {
  3218  		result.Response = autorest.Response{Response: resp}
  3219  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabase", resp, "Failure sending request")
  3220  		return
  3221  	}
  3222  
  3223  	result, err = client.GetMongoDBDatabaseResponder(resp)
  3224  	if err != nil {
  3225  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabase", resp, "Failure responding to request")
  3226  		return
  3227  	}
  3228  
  3229  	return
  3230  }
  3231  
  3232  // GetMongoDBDatabasePreparer prepares the GetMongoDBDatabase request.
  3233  func (client DatabaseAccountsClient) GetMongoDBDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  3234  	pathParameters := map[string]interface{}{
  3235  		"accountName":       autorest.Encode("path", accountName),
  3236  		"databaseName":      autorest.Encode("path", databaseName),
  3237  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3238  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3239  	}
  3240  
  3241  	const APIVersion = "2015-04-08"
  3242  	queryParameters := map[string]interface{}{
  3243  		"api-version": APIVersion,
  3244  	}
  3245  
  3246  	preparer := autorest.CreatePreparer(
  3247  		autorest.AsGet(),
  3248  		autorest.WithBaseURL(client.BaseURI),
  3249  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}", pathParameters),
  3250  		autorest.WithQueryParameters(queryParameters))
  3251  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3252  }
  3253  
  3254  // GetMongoDBDatabaseSender sends the GetMongoDBDatabase request. The method will close the
  3255  // http.Response Body if it receives an error.
  3256  func (client DatabaseAccountsClient) GetMongoDBDatabaseSender(req *http.Request) (*http.Response, error) {
  3257  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3258  }
  3259  
  3260  // GetMongoDBDatabaseResponder handles the response to the GetMongoDBDatabase request. The method always
  3261  // closes the http.Response Body.
  3262  func (client DatabaseAccountsClient) GetMongoDBDatabaseResponder(resp *http.Response) (result MongoDBDatabase, err error) {
  3263  	err = autorest.Respond(
  3264  		resp,
  3265  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3266  		autorest.ByUnmarshallingJSON(&result),
  3267  		autorest.ByClosing())
  3268  	result.Response = autorest.Response{Response: resp}
  3269  	return
  3270  }
  3271  
  3272  // GetMongoDBDatabaseThroughput gets the RUs per second of the MongoDB database under an existing Azure Cosmos DB
  3273  // database account with the provided name.
  3274  // Parameters:
  3275  // resourceGroupName - name of an Azure resource group.
  3276  // accountName - cosmos DB database account name.
  3277  // databaseName - cosmos DB database name.
  3278  func (client DatabaseAccountsClient) GetMongoDBDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result Throughput, err error) {
  3279  	if tracing.IsEnabled() {
  3280  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetMongoDBDatabaseThroughput")
  3281  		defer func() {
  3282  			sc := -1
  3283  			if result.Response.Response != nil {
  3284  				sc = result.Response.Response.StatusCode
  3285  			}
  3286  			tracing.EndSpan(ctx, sc, err)
  3287  		}()
  3288  	}
  3289  	if err := validation.Validate([]validation.Validation{
  3290  		{TargetValue: resourceGroupName,
  3291  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3292  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3293  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3294  		{TargetValue: accountName,
  3295  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3296  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3297  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3298  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetMongoDBDatabaseThroughput", err.Error())
  3299  	}
  3300  
  3301  	req, err := client.GetMongoDBDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName)
  3302  	if err != nil {
  3303  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabaseThroughput", nil, "Failure preparing request")
  3304  		return
  3305  	}
  3306  
  3307  	resp, err := client.GetMongoDBDatabaseThroughputSender(req)
  3308  	if err != nil {
  3309  		result.Response = autorest.Response{Response: resp}
  3310  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabaseThroughput", resp, "Failure sending request")
  3311  		return
  3312  	}
  3313  
  3314  	result, err = client.GetMongoDBDatabaseThroughputResponder(resp)
  3315  	if err != nil {
  3316  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetMongoDBDatabaseThroughput", resp, "Failure responding to request")
  3317  		return
  3318  	}
  3319  
  3320  	return
  3321  }
  3322  
  3323  // GetMongoDBDatabaseThroughputPreparer prepares the GetMongoDBDatabaseThroughput request.
  3324  func (client DatabaseAccountsClient) GetMongoDBDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  3325  	pathParameters := map[string]interface{}{
  3326  		"accountName":       autorest.Encode("path", accountName),
  3327  		"databaseName":      autorest.Encode("path", databaseName),
  3328  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3329  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3330  	}
  3331  
  3332  	const APIVersion = "2015-04-08"
  3333  	queryParameters := map[string]interface{}{
  3334  		"api-version": APIVersion,
  3335  	}
  3336  
  3337  	preparer := autorest.CreatePreparer(
  3338  		autorest.AsGet(),
  3339  		autorest.WithBaseURL(client.BaseURI),
  3340  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/settings/throughput", pathParameters),
  3341  		autorest.WithQueryParameters(queryParameters))
  3342  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3343  }
  3344  
  3345  // GetMongoDBDatabaseThroughputSender sends the GetMongoDBDatabaseThroughput request. The method will close the
  3346  // http.Response Body if it receives an error.
  3347  func (client DatabaseAccountsClient) GetMongoDBDatabaseThroughputSender(req *http.Request) (*http.Response, error) {
  3348  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3349  }
  3350  
  3351  // GetMongoDBDatabaseThroughputResponder handles the response to the GetMongoDBDatabaseThroughput request. The method always
  3352  // closes the http.Response Body.
  3353  func (client DatabaseAccountsClient) GetMongoDBDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  3354  	err = autorest.Respond(
  3355  		resp,
  3356  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3357  		autorest.ByUnmarshallingJSON(&result),
  3358  		autorest.ByClosing())
  3359  	result.Response = autorest.Response{Response: resp}
  3360  	return
  3361  }
  3362  
  3363  // GetReadOnlyKeys lists the read-only access keys for the specified Azure Cosmos DB database account.
  3364  // Parameters:
  3365  // resourceGroupName - name of an Azure resource group.
  3366  // accountName - cosmos DB database account name.
  3367  func (client DatabaseAccountsClient) GetReadOnlyKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  3368  	if tracing.IsEnabled() {
  3369  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetReadOnlyKeys")
  3370  		defer func() {
  3371  			sc := -1
  3372  			if result.Response.Response != nil {
  3373  				sc = result.Response.Response.StatusCode
  3374  			}
  3375  			tracing.EndSpan(ctx, sc, err)
  3376  		}()
  3377  	}
  3378  	if err := validation.Validate([]validation.Validation{
  3379  		{TargetValue: resourceGroupName,
  3380  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3381  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3382  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3383  		{TargetValue: accountName,
  3384  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3385  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3386  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3387  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", err.Error())
  3388  	}
  3389  
  3390  	req, err := client.GetReadOnlyKeysPreparer(ctx, resourceGroupName, accountName)
  3391  	if err != nil {
  3392  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", nil, "Failure preparing request")
  3393  		return
  3394  	}
  3395  
  3396  	resp, err := client.GetReadOnlyKeysSender(req)
  3397  	if err != nil {
  3398  		result.Response = autorest.Response{Response: resp}
  3399  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", resp, "Failure sending request")
  3400  		return
  3401  	}
  3402  
  3403  	result, err = client.GetReadOnlyKeysResponder(resp)
  3404  	if err != nil {
  3405  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", resp, "Failure responding to request")
  3406  		return
  3407  	}
  3408  
  3409  	return
  3410  }
  3411  
  3412  // GetReadOnlyKeysPreparer prepares the GetReadOnlyKeys request.
  3413  func (client DatabaseAccountsClient) GetReadOnlyKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  3414  	pathParameters := map[string]interface{}{
  3415  		"accountName":       autorest.Encode("path", accountName),
  3416  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3417  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3418  	}
  3419  
  3420  	const APIVersion = "2015-04-08"
  3421  	queryParameters := map[string]interface{}{
  3422  		"api-version": APIVersion,
  3423  	}
  3424  
  3425  	preparer := autorest.CreatePreparer(
  3426  		autorest.AsGet(),
  3427  		autorest.WithBaseURL(client.BaseURI),
  3428  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/readonlykeys", pathParameters),
  3429  		autorest.WithQueryParameters(queryParameters))
  3430  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3431  }
  3432  
  3433  // GetReadOnlyKeysSender sends the GetReadOnlyKeys request. The method will close the
  3434  // http.Response Body if it receives an error.
  3435  func (client DatabaseAccountsClient) GetReadOnlyKeysSender(req *http.Request) (*http.Response, error) {
  3436  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3437  }
  3438  
  3439  // GetReadOnlyKeysResponder handles the response to the GetReadOnlyKeys request. The method always
  3440  // closes the http.Response Body.
  3441  func (client DatabaseAccountsClient) GetReadOnlyKeysResponder(resp *http.Response) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  3442  	err = autorest.Respond(
  3443  		resp,
  3444  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3445  		autorest.ByUnmarshallingJSON(&result),
  3446  		autorest.ByClosing())
  3447  	result.Response = autorest.Response{Response: resp}
  3448  	return
  3449  }
  3450  
  3451  // GetSQLContainer gets the SQL container under an existing Azure Cosmos DB database account.
  3452  // Parameters:
  3453  // resourceGroupName - name of an Azure resource group.
  3454  // accountName - cosmos DB database account name.
  3455  // databaseName - cosmos DB database name.
  3456  // containerName - cosmos DB container name.
  3457  func (client DatabaseAccountsClient) GetSQLContainer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result SQLContainer, err error) {
  3458  	if tracing.IsEnabled() {
  3459  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetSQLContainer")
  3460  		defer func() {
  3461  			sc := -1
  3462  			if result.Response.Response != nil {
  3463  				sc = result.Response.Response.StatusCode
  3464  			}
  3465  			tracing.EndSpan(ctx, sc, err)
  3466  		}()
  3467  	}
  3468  	if err := validation.Validate([]validation.Validation{
  3469  		{TargetValue: resourceGroupName,
  3470  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3471  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3472  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3473  		{TargetValue: accountName,
  3474  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3475  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3476  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3477  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetSQLContainer", err.Error())
  3478  	}
  3479  
  3480  	req, err := client.GetSQLContainerPreparer(ctx, resourceGroupName, accountName, databaseName, containerName)
  3481  	if err != nil {
  3482  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainer", nil, "Failure preparing request")
  3483  		return
  3484  	}
  3485  
  3486  	resp, err := client.GetSQLContainerSender(req)
  3487  	if err != nil {
  3488  		result.Response = autorest.Response{Response: resp}
  3489  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainer", resp, "Failure sending request")
  3490  		return
  3491  	}
  3492  
  3493  	result, err = client.GetSQLContainerResponder(resp)
  3494  	if err != nil {
  3495  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainer", resp, "Failure responding to request")
  3496  		return
  3497  	}
  3498  
  3499  	return
  3500  }
  3501  
  3502  // GetSQLContainerPreparer prepares the GetSQLContainer request.
  3503  func (client DatabaseAccountsClient) GetSQLContainerPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) {
  3504  	pathParameters := map[string]interface{}{
  3505  		"accountName":       autorest.Encode("path", accountName),
  3506  		"containerName":     autorest.Encode("path", containerName),
  3507  		"databaseName":      autorest.Encode("path", databaseName),
  3508  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3509  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3510  	}
  3511  
  3512  	const APIVersion = "2015-04-08"
  3513  	queryParameters := map[string]interface{}{
  3514  		"api-version": APIVersion,
  3515  	}
  3516  
  3517  	preparer := autorest.CreatePreparer(
  3518  		autorest.AsGet(),
  3519  		autorest.WithBaseURL(client.BaseURI),
  3520  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers/{containerName}", pathParameters),
  3521  		autorest.WithQueryParameters(queryParameters))
  3522  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3523  }
  3524  
  3525  // GetSQLContainerSender sends the GetSQLContainer request. The method will close the
  3526  // http.Response Body if it receives an error.
  3527  func (client DatabaseAccountsClient) GetSQLContainerSender(req *http.Request) (*http.Response, error) {
  3528  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3529  }
  3530  
  3531  // GetSQLContainerResponder handles the response to the GetSQLContainer request. The method always
  3532  // closes the http.Response Body.
  3533  func (client DatabaseAccountsClient) GetSQLContainerResponder(resp *http.Response) (result SQLContainer, err error) {
  3534  	err = autorest.Respond(
  3535  		resp,
  3536  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3537  		autorest.ByUnmarshallingJSON(&result),
  3538  		autorest.ByClosing())
  3539  	result.Response = autorest.Response{Response: resp}
  3540  	return
  3541  }
  3542  
  3543  // GetSQLContainerThroughput gets the RUs per second of the SQL container under an existing Azure Cosmos DB database
  3544  // account.
  3545  // Parameters:
  3546  // resourceGroupName - name of an Azure resource group.
  3547  // accountName - cosmos DB database account name.
  3548  // databaseName - cosmos DB database name.
  3549  // containerName - cosmos DB container name.
  3550  func (client DatabaseAccountsClient) GetSQLContainerThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (result Throughput, err error) {
  3551  	if tracing.IsEnabled() {
  3552  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetSQLContainerThroughput")
  3553  		defer func() {
  3554  			sc := -1
  3555  			if result.Response.Response != nil {
  3556  				sc = result.Response.Response.StatusCode
  3557  			}
  3558  			tracing.EndSpan(ctx, sc, err)
  3559  		}()
  3560  	}
  3561  	if err := validation.Validate([]validation.Validation{
  3562  		{TargetValue: resourceGroupName,
  3563  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3564  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3565  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3566  		{TargetValue: accountName,
  3567  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3568  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3569  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3570  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetSQLContainerThroughput", err.Error())
  3571  	}
  3572  
  3573  	req, err := client.GetSQLContainerThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, containerName)
  3574  	if err != nil {
  3575  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainerThroughput", nil, "Failure preparing request")
  3576  		return
  3577  	}
  3578  
  3579  	resp, err := client.GetSQLContainerThroughputSender(req)
  3580  	if err != nil {
  3581  		result.Response = autorest.Response{Response: resp}
  3582  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainerThroughput", resp, "Failure sending request")
  3583  		return
  3584  	}
  3585  
  3586  	result, err = client.GetSQLContainerThroughputResponder(resp)
  3587  	if err != nil {
  3588  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLContainerThroughput", resp, "Failure responding to request")
  3589  		return
  3590  	}
  3591  
  3592  	return
  3593  }
  3594  
  3595  // GetSQLContainerThroughputPreparer prepares the GetSQLContainerThroughput request.
  3596  func (client DatabaseAccountsClient) GetSQLContainerThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string) (*http.Request, error) {
  3597  	pathParameters := map[string]interface{}{
  3598  		"accountName":       autorest.Encode("path", accountName),
  3599  		"containerName":     autorest.Encode("path", containerName),
  3600  		"databaseName":      autorest.Encode("path", databaseName),
  3601  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3602  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3603  	}
  3604  
  3605  	const APIVersion = "2015-04-08"
  3606  	queryParameters := map[string]interface{}{
  3607  		"api-version": APIVersion,
  3608  	}
  3609  
  3610  	preparer := autorest.CreatePreparer(
  3611  		autorest.AsGet(),
  3612  		autorest.WithBaseURL(client.BaseURI),
  3613  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers/{containerName}/settings/throughput", pathParameters),
  3614  		autorest.WithQueryParameters(queryParameters))
  3615  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3616  }
  3617  
  3618  // GetSQLContainerThroughputSender sends the GetSQLContainerThroughput request. The method will close the
  3619  // http.Response Body if it receives an error.
  3620  func (client DatabaseAccountsClient) GetSQLContainerThroughputSender(req *http.Request) (*http.Response, error) {
  3621  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3622  }
  3623  
  3624  // GetSQLContainerThroughputResponder handles the response to the GetSQLContainerThroughput request. The method always
  3625  // closes the http.Response Body.
  3626  func (client DatabaseAccountsClient) GetSQLContainerThroughputResponder(resp *http.Response) (result Throughput, err error) {
  3627  	err = autorest.Respond(
  3628  		resp,
  3629  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3630  		autorest.ByUnmarshallingJSON(&result),
  3631  		autorest.ByClosing())
  3632  	result.Response = autorest.Response{Response: resp}
  3633  	return
  3634  }
  3635  
  3636  // GetSQLDatabase gets the SQL database under an existing Azure Cosmos DB database account with the provided name.
  3637  // Parameters:
  3638  // resourceGroupName - name of an Azure resource group.
  3639  // accountName - cosmos DB database account name.
  3640  // databaseName - cosmos DB database name.
  3641  func (client DatabaseAccountsClient) GetSQLDatabase(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLDatabase, err error) {
  3642  	if tracing.IsEnabled() {
  3643  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetSQLDatabase")
  3644  		defer func() {
  3645  			sc := -1
  3646  			if result.Response.Response != nil {
  3647  				sc = result.Response.Response.StatusCode
  3648  			}
  3649  			tracing.EndSpan(ctx, sc, err)
  3650  		}()
  3651  	}
  3652  	if err := validation.Validate([]validation.Validation{
  3653  		{TargetValue: resourceGroupName,
  3654  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3655  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3656  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3657  		{TargetValue: accountName,
  3658  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3659  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3660  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3661  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetSQLDatabase", err.Error())
  3662  	}
  3663  
  3664  	req, err := client.GetSQLDatabasePreparer(ctx, resourceGroupName, accountName, databaseName)
  3665  	if err != nil {
  3666  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabase", nil, "Failure preparing request")
  3667  		return
  3668  	}
  3669  
  3670  	resp, err := client.GetSQLDatabaseSender(req)
  3671  	if err != nil {
  3672  		result.Response = autorest.Response{Response: resp}
  3673  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabase", resp, "Failure sending request")
  3674  		return
  3675  	}
  3676  
  3677  	result, err = client.GetSQLDatabaseResponder(resp)
  3678  	if err != nil {
  3679  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabase", resp, "Failure responding to request")
  3680  		return
  3681  	}
  3682  
  3683  	return
  3684  }
  3685  
  3686  // GetSQLDatabasePreparer prepares the GetSQLDatabase request.
  3687  func (client DatabaseAccountsClient) GetSQLDatabasePreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  3688  	pathParameters := map[string]interface{}{
  3689  		"accountName":       autorest.Encode("path", accountName),
  3690  		"databaseName":      autorest.Encode("path", databaseName),
  3691  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3692  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3693  	}
  3694  
  3695  	const APIVersion = "2015-04-08"
  3696  	queryParameters := map[string]interface{}{
  3697  		"api-version": APIVersion,
  3698  	}
  3699  
  3700  	preparer := autorest.CreatePreparer(
  3701  		autorest.AsGet(),
  3702  		autorest.WithBaseURL(client.BaseURI),
  3703  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}", pathParameters),
  3704  		autorest.WithQueryParameters(queryParameters))
  3705  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3706  }
  3707  
  3708  // GetSQLDatabaseSender sends the GetSQLDatabase request. The method will close the
  3709  // http.Response Body if it receives an error.
  3710  func (client DatabaseAccountsClient) GetSQLDatabaseSender(req *http.Request) (*http.Response, error) {
  3711  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3712  }
  3713  
  3714  // GetSQLDatabaseResponder handles the response to the GetSQLDatabase request. The method always
  3715  // closes the http.Response Body.
  3716  func (client DatabaseAccountsClient) GetSQLDatabaseResponder(resp *http.Response) (result SQLDatabase, err error) {
  3717  	err = autorest.Respond(
  3718  		resp,
  3719  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3720  		autorest.ByUnmarshallingJSON(&result),
  3721  		autorest.ByClosing())
  3722  	result.Response = autorest.Response{Response: resp}
  3723  	return
  3724  }
  3725  
  3726  // GetSQLDatabaseThroughput gets the RUs per second of the SQL database under an existing Azure Cosmos DB database
  3727  // account with the provided name.
  3728  // Parameters:
  3729  // resourceGroupName - name of an Azure resource group.
  3730  // accountName - cosmos DB database account name.
  3731  // databaseName - cosmos DB database name.
  3732  func (client DatabaseAccountsClient) GetSQLDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result Throughput, err error) {
  3733  	if tracing.IsEnabled() {
  3734  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetSQLDatabaseThroughput")
  3735  		defer func() {
  3736  			sc := -1
  3737  			if result.Response.Response != nil {
  3738  				sc = result.Response.Response.StatusCode
  3739  			}
  3740  			tracing.EndSpan(ctx, sc, err)
  3741  		}()
  3742  	}
  3743  	if err := validation.Validate([]validation.Validation{
  3744  		{TargetValue: resourceGroupName,
  3745  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3746  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3747  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3748  		{TargetValue: accountName,
  3749  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3750  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3751  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3752  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetSQLDatabaseThroughput", err.Error())
  3753  	}
  3754  
  3755  	req, err := client.GetSQLDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName)
  3756  	if err != nil {
  3757  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabaseThroughput", nil, "Failure preparing request")
  3758  		return
  3759  	}
  3760  
  3761  	resp, err := client.GetSQLDatabaseThroughputSender(req)
  3762  	if err != nil {
  3763  		result.Response = autorest.Response{Response: resp}
  3764  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabaseThroughput", resp, "Failure sending request")
  3765  		return
  3766  	}
  3767  
  3768  	result, err = client.GetSQLDatabaseThroughputResponder(resp)
  3769  	if err != nil {
  3770  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetSQLDatabaseThroughput", resp, "Failure responding to request")
  3771  		return
  3772  	}
  3773  
  3774  	return
  3775  }
  3776  
  3777  // GetSQLDatabaseThroughputPreparer prepares the GetSQLDatabaseThroughput request.
  3778  func (client DatabaseAccountsClient) GetSQLDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  3779  	pathParameters := map[string]interface{}{
  3780  		"accountName":       autorest.Encode("path", accountName),
  3781  		"databaseName":      autorest.Encode("path", databaseName),
  3782  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3783  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3784  	}
  3785  
  3786  	const APIVersion = "2015-04-08"
  3787  	queryParameters := map[string]interface{}{
  3788  		"api-version": APIVersion,
  3789  	}
  3790  
  3791  	preparer := autorest.CreatePreparer(
  3792  		autorest.AsGet(),
  3793  		autorest.WithBaseURL(client.BaseURI),
  3794  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/settings/throughput", pathParameters),
  3795  		autorest.WithQueryParameters(queryParameters))
  3796  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3797  }
  3798  
  3799  // GetSQLDatabaseThroughputSender sends the GetSQLDatabaseThroughput request. The method will close the
  3800  // http.Response Body if it receives an error.
  3801  func (client DatabaseAccountsClient) GetSQLDatabaseThroughputSender(req *http.Request) (*http.Response, error) {
  3802  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3803  }
  3804  
  3805  // GetSQLDatabaseThroughputResponder handles the response to the GetSQLDatabaseThroughput request. The method always
  3806  // closes the http.Response Body.
  3807  func (client DatabaseAccountsClient) GetSQLDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  3808  	err = autorest.Respond(
  3809  		resp,
  3810  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3811  		autorest.ByUnmarshallingJSON(&result),
  3812  		autorest.ByClosing())
  3813  	result.Response = autorest.Response{Response: resp}
  3814  	return
  3815  }
  3816  
  3817  // GetTable gets the Tables under an existing Azure Cosmos DB database account with the provided name.
  3818  // Parameters:
  3819  // resourceGroupName - name of an Azure resource group.
  3820  // accountName - cosmos DB database account name.
  3821  // tableName - cosmos DB table name.
  3822  func (client DatabaseAccountsClient) GetTable(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result Table, err error) {
  3823  	if tracing.IsEnabled() {
  3824  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetTable")
  3825  		defer func() {
  3826  			sc := -1
  3827  			if result.Response.Response != nil {
  3828  				sc = result.Response.Response.StatusCode
  3829  			}
  3830  			tracing.EndSpan(ctx, sc, err)
  3831  		}()
  3832  	}
  3833  	if err := validation.Validate([]validation.Validation{
  3834  		{TargetValue: resourceGroupName,
  3835  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3836  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3837  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3838  		{TargetValue: accountName,
  3839  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3840  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3841  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3842  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetTable", err.Error())
  3843  	}
  3844  
  3845  	req, err := client.GetTablePreparer(ctx, resourceGroupName, accountName, tableName)
  3846  	if err != nil {
  3847  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTable", nil, "Failure preparing request")
  3848  		return
  3849  	}
  3850  
  3851  	resp, err := client.GetTableSender(req)
  3852  	if err != nil {
  3853  		result.Response = autorest.Response{Response: resp}
  3854  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTable", resp, "Failure sending request")
  3855  		return
  3856  	}
  3857  
  3858  	result, err = client.GetTableResponder(resp)
  3859  	if err != nil {
  3860  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTable", resp, "Failure responding to request")
  3861  		return
  3862  	}
  3863  
  3864  	return
  3865  }
  3866  
  3867  // GetTablePreparer prepares the GetTable request.
  3868  func (client DatabaseAccountsClient) GetTablePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
  3869  	pathParameters := map[string]interface{}{
  3870  		"accountName":       autorest.Encode("path", accountName),
  3871  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3872  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3873  		"tableName":         autorest.Encode("path", tableName),
  3874  	}
  3875  
  3876  	const APIVersion = "2015-04-08"
  3877  	queryParameters := map[string]interface{}{
  3878  		"api-version": APIVersion,
  3879  	}
  3880  
  3881  	preparer := autorest.CreatePreparer(
  3882  		autorest.AsGet(),
  3883  		autorest.WithBaseURL(client.BaseURI),
  3884  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables/{tableName}", pathParameters),
  3885  		autorest.WithQueryParameters(queryParameters))
  3886  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3887  }
  3888  
  3889  // GetTableSender sends the GetTable request. The method will close the
  3890  // http.Response Body if it receives an error.
  3891  func (client DatabaseAccountsClient) GetTableSender(req *http.Request) (*http.Response, error) {
  3892  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3893  }
  3894  
  3895  // GetTableResponder handles the response to the GetTable request. The method always
  3896  // closes the http.Response Body.
  3897  func (client DatabaseAccountsClient) GetTableResponder(resp *http.Response) (result Table, err error) {
  3898  	err = autorest.Respond(
  3899  		resp,
  3900  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3901  		autorest.ByUnmarshallingJSON(&result),
  3902  		autorest.ByClosing())
  3903  	result.Response = autorest.Response{Response: resp}
  3904  	return
  3905  }
  3906  
  3907  // GetTableThroughput gets the RUs per second of the Table under an existing Azure Cosmos DB database account with the
  3908  // provided name.
  3909  // Parameters:
  3910  // resourceGroupName - name of an Azure resource group.
  3911  // accountName - cosmos DB database account name.
  3912  // tableName - cosmos DB table name.
  3913  func (client DatabaseAccountsClient) GetTableThroughput(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result Throughput, err error) {
  3914  	if tracing.IsEnabled() {
  3915  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetTableThroughput")
  3916  		defer func() {
  3917  			sc := -1
  3918  			if result.Response.Response != nil {
  3919  				sc = result.Response.Response.StatusCode
  3920  			}
  3921  			tracing.EndSpan(ctx, sc, err)
  3922  		}()
  3923  	}
  3924  	if err := validation.Validate([]validation.Validation{
  3925  		{TargetValue: resourceGroupName,
  3926  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  3927  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  3928  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  3929  		{TargetValue: accountName,
  3930  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  3931  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  3932  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  3933  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetTableThroughput", err.Error())
  3934  	}
  3935  
  3936  	req, err := client.GetTableThroughputPreparer(ctx, resourceGroupName, accountName, tableName)
  3937  	if err != nil {
  3938  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTableThroughput", nil, "Failure preparing request")
  3939  		return
  3940  	}
  3941  
  3942  	resp, err := client.GetTableThroughputSender(req)
  3943  	if err != nil {
  3944  		result.Response = autorest.Response{Response: resp}
  3945  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTableThroughput", resp, "Failure sending request")
  3946  		return
  3947  	}
  3948  
  3949  	result, err = client.GetTableThroughputResponder(resp)
  3950  	if err != nil {
  3951  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetTableThroughput", resp, "Failure responding to request")
  3952  		return
  3953  	}
  3954  
  3955  	return
  3956  }
  3957  
  3958  // GetTableThroughputPreparer prepares the GetTableThroughput request.
  3959  func (client DatabaseAccountsClient) GetTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
  3960  	pathParameters := map[string]interface{}{
  3961  		"accountName":       autorest.Encode("path", accountName),
  3962  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  3963  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  3964  		"tableName":         autorest.Encode("path", tableName),
  3965  	}
  3966  
  3967  	const APIVersion = "2015-04-08"
  3968  	queryParameters := map[string]interface{}{
  3969  		"api-version": APIVersion,
  3970  	}
  3971  
  3972  	preparer := autorest.CreatePreparer(
  3973  		autorest.AsGet(),
  3974  		autorest.WithBaseURL(client.BaseURI),
  3975  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables/{tableName}/settings/throughput", pathParameters),
  3976  		autorest.WithQueryParameters(queryParameters))
  3977  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3978  }
  3979  
  3980  // GetTableThroughputSender sends the GetTableThroughput request. The method will close the
  3981  // http.Response Body if it receives an error.
  3982  func (client DatabaseAccountsClient) GetTableThroughputSender(req *http.Request) (*http.Response, error) {
  3983  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  3984  }
  3985  
  3986  // GetTableThroughputResponder handles the response to the GetTableThroughput request. The method always
  3987  // closes the http.Response Body.
  3988  func (client DatabaseAccountsClient) GetTableThroughputResponder(resp *http.Response) (result Throughput, err error) {
  3989  	err = autorest.Respond(
  3990  		resp,
  3991  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3992  		autorest.ByUnmarshallingJSON(&result),
  3993  		autorest.ByClosing())
  3994  	result.Response = autorest.Response{Response: resp}
  3995  	return
  3996  }
  3997  
  3998  // List lists all the Azure Cosmos DB database accounts available under the subscription.
  3999  func (client DatabaseAccountsClient) List(ctx context.Context) (result DatabaseAccountsListResult, err error) {
  4000  	if tracing.IsEnabled() {
  4001  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.List")
  4002  		defer func() {
  4003  			sc := -1
  4004  			if result.Response.Response != nil {
  4005  				sc = result.Response.Response.StatusCode
  4006  			}
  4007  			tracing.EndSpan(ctx, sc, err)
  4008  		}()
  4009  	}
  4010  	req, err := client.ListPreparer(ctx)
  4011  	if err != nil {
  4012  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", nil, "Failure preparing request")
  4013  		return
  4014  	}
  4015  
  4016  	resp, err := client.ListSender(req)
  4017  	if err != nil {
  4018  		result.Response = autorest.Response{Response: resp}
  4019  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", resp, "Failure sending request")
  4020  		return
  4021  	}
  4022  
  4023  	result, err = client.ListResponder(resp)
  4024  	if err != nil {
  4025  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", resp, "Failure responding to request")
  4026  		return
  4027  	}
  4028  
  4029  	return
  4030  }
  4031  
  4032  // ListPreparer prepares the List request.
  4033  func (client DatabaseAccountsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
  4034  	pathParameters := map[string]interface{}{
  4035  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
  4036  	}
  4037  
  4038  	const APIVersion = "2015-04-08"
  4039  	queryParameters := map[string]interface{}{
  4040  		"api-version": APIVersion,
  4041  	}
  4042  
  4043  	preparer := autorest.CreatePreparer(
  4044  		autorest.AsGet(),
  4045  		autorest.WithBaseURL(client.BaseURI),
  4046  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/databaseAccounts", pathParameters),
  4047  		autorest.WithQueryParameters(queryParameters))
  4048  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4049  }
  4050  
  4051  // ListSender sends the List request. The method will close the
  4052  // http.Response Body if it receives an error.
  4053  func (client DatabaseAccountsClient) ListSender(req *http.Request) (*http.Response, error) {
  4054  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4055  }
  4056  
  4057  // ListResponder handles the response to the List request. The method always
  4058  // closes the http.Response Body.
  4059  func (client DatabaseAccountsClient) ListResponder(resp *http.Response) (result DatabaseAccountsListResult, err error) {
  4060  	err = autorest.Respond(
  4061  		resp,
  4062  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4063  		autorest.ByUnmarshallingJSON(&result),
  4064  		autorest.ByClosing())
  4065  	result.Response = autorest.Response{Response: resp}
  4066  	return
  4067  }
  4068  
  4069  // ListByResourceGroup lists all the Azure Cosmos DB database accounts available under the given resource group.
  4070  // Parameters:
  4071  // resourceGroupName - name of an Azure resource group.
  4072  func (client DatabaseAccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result DatabaseAccountsListResult, err error) {
  4073  	if tracing.IsEnabled() {
  4074  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListByResourceGroup")
  4075  		defer func() {
  4076  			sc := -1
  4077  			if result.Response.Response != nil {
  4078  				sc = result.Response.Response.StatusCode
  4079  			}
  4080  			tracing.EndSpan(ctx, sc, err)
  4081  		}()
  4082  	}
  4083  	if err := validation.Validate([]validation.Validation{
  4084  		{TargetValue: resourceGroupName,
  4085  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4086  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4087  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
  4088  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListByResourceGroup", err.Error())
  4089  	}
  4090  
  4091  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
  4092  	if err != nil {
  4093  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", nil, "Failure preparing request")
  4094  		return
  4095  	}
  4096  
  4097  	resp, err := client.ListByResourceGroupSender(req)
  4098  	if err != nil {
  4099  		result.Response = autorest.Response{Response: resp}
  4100  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", resp, "Failure sending request")
  4101  		return
  4102  	}
  4103  
  4104  	result, err = client.ListByResourceGroupResponder(resp)
  4105  	if err != nil {
  4106  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", resp, "Failure responding to request")
  4107  		return
  4108  	}
  4109  
  4110  	return
  4111  }
  4112  
  4113  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
  4114  func (client DatabaseAccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
  4115  	pathParameters := map[string]interface{}{
  4116  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4117  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4118  	}
  4119  
  4120  	const APIVersion = "2015-04-08"
  4121  	queryParameters := map[string]interface{}{
  4122  		"api-version": APIVersion,
  4123  	}
  4124  
  4125  	preparer := autorest.CreatePreparer(
  4126  		autorest.AsGet(),
  4127  		autorest.WithBaseURL(client.BaseURI),
  4128  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts", pathParameters),
  4129  		autorest.WithQueryParameters(queryParameters))
  4130  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4131  }
  4132  
  4133  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
  4134  // http.Response Body if it receives an error.
  4135  func (client DatabaseAccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
  4136  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4137  }
  4138  
  4139  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
  4140  // closes the http.Response Body.
  4141  func (client DatabaseAccountsClient) ListByResourceGroupResponder(resp *http.Response) (result DatabaseAccountsListResult, err error) {
  4142  	err = autorest.Respond(
  4143  		resp,
  4144  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4145  		autorest.ByUnmarshallingJSON(&result),
  4146  		autorest.ByClosing())
  4147  	result.Response = autorest.Response{Response: resp}
  4148  	return
  4149  }
  4150  
  4151  // ListCassandraKeyspaces lists the Cassandra keyspaces under an existing Azure Cosmos DB database account.
  4152  // Parameters:
  4153  // resourceGroupName - name of an Azure resource group.
  4154  // accountName - cosmos DB database account name.
  4155  func (client DatabaseAccountsClient) ListCassandraKeyspaces(ctx context.Context, resourceGroupName string, accountName string) (result CassandraKeyspaceListResult, err error) {
  4156  	if tracing.IsEnabled() {
  4157  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListCassandraKeyspaces")
  4158  		defer func() {
  4159  			sc := -1
  4160  			if result.Response.Response != nil {
  4161  				sc = result.Response.Response.StatusCode
  4162  			}
  4163  			tracing.EndSpan(ctx, sc, err)
  4164  		}()
  4165  	}
  4166  	if err := validation.Validate([]validation.Validation{
  4167  		{TargetValue: resourceGroupName,
  4168  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4169  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4170  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4171  		{TargetValue: accountName,
  4172  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4173  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4174  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4175  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListCassandraKeyspaces", err.Error())
  4176  	}
  4177  
  4178  	req, err := client.ListCassandraKeyspacesPreparer(ctx, resourceGroupName, accountName)
  4179  	if err != nil {
  4180  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraKeyspaces", nil, "Failure preparing request")
  4181  		return
  4182  	}
  4183  
  4184  	resp, err := client.ListCassandraKeyspacesSender(req)
  4185  	if err != nil {
  4186  		result.Response = autorest.Response{Response: resp}
  4187  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraKeyspaces", resp, "Failure sending request")
  4188  		return
  4189  	}
  4190  
  4191  	result, err = client.ListCassandraKeyspacesResponder(resp)
  4192  	if err != nil {
  4193  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraKeyspaces", resp, "Failure responding to request")
  4194  		return
  4195  	}
  4196  
  4197  	return
  4198  }
  4199  
  4200  // ListCassandraKeyspacesPreparer prepares the ListCassandraKeyspaces request.
  4201  func (client DatabaseAccountsClient) ListCassandraKeyspacesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  4202  	pathParameters := map[string]interface{}{
  4203  		"accountName":       autorest.Encode("path", accountName),
  4204  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4205  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4206  	}
  4207  
  4208  	const APIVersion = "2015-04-08"
  4209  	queryParameters := map[string]interface{}{
  4210  		"api-version": APIVersion,
  4211  	}
  4212  
  4213  	preparer := autorest.CreatePreparer(
  4214  		autorest.AsGet(),
  4215  		autorest.WithBaseURL(client.BaseURI),
  4216  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces", pathParameters),
  4217  		autorest.WithQueryParameters(queryParameters))
  4218  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4219  }
  4220  
  4221  // ListCassandraKeyspacesSender sends the ListCassandraKeyspaces request. The method will close the
  4222  // http.Response Body if it receives an error.
  4223  func (client DatabaseAccountsClient) ListCassandraKeyspacesSender(req *http.Request) (*http.Response, error) {
  4224  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4225  }
  4226  
  4227  // ListCassandraKeyspacesResponder handles the response to the ListCassandraKeyspaces request. The method always
  4228  // closes the http.Response Body.
  4229  func (client DatabaseAccountsClient) ListCassandraKeyspacesResponder(resp *http.Response) (result CassandraKeyspaceListResult, err error) {
  4230  	err = autorest.Respond(
  4231  		resp,
  4232  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4233  		autorest.ByUnmarshallingJSON(&result),
  4234  		autorest.ByClosing())
  4235  	result.Response = autorest.Response{Response: resp}
  4236  	return
  4237  }
  4238  
  4239  // ListCassandraTables lists the Cassandra table under an existing Azure Cosmos DB database account.
  4240  // Parameters:
  4241  // resourceGroupName - name of an Azure resource group.
  4242  // accountName - cosmos DB database account name.
  4243  // keyspaceName - cosmos DB keyspace name.
  4244  func (client DatabaseAccountsClient) ListCassandraTables(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (result CassandraTableListResult, err error) {
  4245  	if tracing.IsEnabled() {
  4246  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListCassandraTables")
  4247  		defer func() {
  4248  			sc := -1
  4249  			if result.Response.Response != nil {
  4250  				sc = result.Response.Response.StatusCode
  4251  			}
  4252  			tracing.EndSpan(ctx, sc, err)
  4253  		}()
  4254  	}
  4255  	if err := validation.Validate([]validation.Validation{
  4256  		{TargetValue: resourceGroupName,
  4257  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4258  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4259  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4260  		{TargetValue: accountName,
  4261  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4262  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4263  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4264  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListCassandraTables", err.Error())
  4265  	}
  4266  
  4267  	req, err := client.ListCassandraTablesPreparer(ctx, resourceGroupName, accountName, keyspaceName)
  4268  	if err != nil {
  4269  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraTables", nil, "Failure preparing request")
  4270  		return
  4271  	}
  4272  
  4273  	resp, err := client.ListCassandraTablesSender(req)
  4274  	if err != nil {
  4275  		result.Response = autorest.Response{Response: resp}
  4276  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraTables", resp, "Failure sending request")
  4277  		return
  4278  	}
  4279  
  4280  	result, err = client.ListCassandraTablesResponder(resp)
  4281  	if err != nil {
  4282  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListCassandraTables", resp, "Failure responding to request")
  4283  		return
  4284  	}
  4285  
  4286  	return
  4287  }
  4288  
  4289  // ListCassandraTablesPreparer prepares the ListCassandraTables request.
  4290  func (client DatabaseAccountsClient) ListCassandraTablesPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string) (*http.Request, error) {
  4291  	pathParameters := map[string]interface{}{
  4292  		"accountName":       autorest.Encode("path", accountName),
  4293  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  4294  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4295  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4296  	}
  4297  
  4298  	const APIVersion = "2015-04-08"
  4299  	queryParameters := map[string]interface{}{
  4300  		"api-version": APIVersion,
  4301  	}
  4302  
  4303  	preparer := autorest.CreatePreparer(
  4304  		autorest.AsGet(),
  4305  		autorest.WithBaseURL(client.BaseURI),
  4306  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables", pathParameters),
  4307  		autorest.WithQueryParameters(queryParameters))
  4308  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4309  }
  4310  
  4311  // ListCassandraTablesSender sends the ListCassandraTables request. The method will close the
  4312  // http.Response Body if it receives an error.
  4313  func (client DatabaseAccountsClient) ListCassandraTablesSender(req *http.Request) (*http.Response, error) {
  4314  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4315  }
  4316  
  4317  // ListCassandraTablesResponder handles the response to the ListCassandraTables request. The method always
  4318  // closes the http.Response Body.
  4319  func (client DatabaseAccountsClient) ListCassandraTablesResponder(resp *http.Response) (result CassandraTableListResult, err error) {
  4320  	err = autorest.Respond(
  4321  		resp,
  4322  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4323  		autorest.ByUnmarshallingJSON(&result),
  4324  		autorest.ByClosing())
  4325  	result.Response = autorest.Response{Response: resp}
  4326  	return
  4327  }
  4328  
  4329  // ListConnectionStrings lists the connection strings for the specified Azure Cosmos DB database account.
  4330  // Parameters:
  4331  // resourceGroupName - name of an Azure resource group.
  4332  // accountName - cosmos DB database account name.
  4333  func (client DatabaseAccountsClient) ListConnectionStrings(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListConnectionStringsResult, err error) {
  4334  	if tracing.IsEnabled() {
  4335  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListConnectionStrings")
  4336  		defer func() {
  4337  			sc := -1
  4338  			if result.Response.Response != nil {
  4339  				sc = result.Response.Response.StatusCode
  4340  			}
  4341  			tracing.EndSpan(ctx, sc, err)
  4342  		}()
  4343  	}
  4344  	if err := validation.Validate([]validation.Validation{
  4345  		{TargetValue: resourceGroupName,
  4346  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4347  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4348  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4349  		{TargetValue: accountName,
  4350  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4351  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4352  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4353  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListConnectionStrings", err.Error())
  4354  	}
  4355  
  4356  	req, err := client.ListConnectionStringsPreparer(ctx, resourceGroupName, accountName)
  4357  	if err != nil {
  4358  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", nil, "Failure preparing request")
  4359  		return
  4360  	}
  4361  
  4362  	resp, err := client.ListConnectionStringsSender(req)
  4363  	if err != nil {
  4364  		result.Response = autorest.Response{Response: resp}
  4365  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", resp, "Failure sending request")
  4366  		return
  4367  	}
  4368  
  4369  	result, err = client.ListConnectionStringsResponder(resp)
  4370  	if err != nil {
  4371  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", resp, "Failure responding to request")
  4372  		return
  4373  	}
  4374  
  4375  	return
  4376  }
  4377  
  4378  // ListConnectionStringsPreparer prepares the ListConnectionStrings request.
  4379  func (client DatabaseAccountsClient) ListConnectionStringsPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  4380  	pathParameters := map[string]interface{}{
  4381  		"accountName":       autorest.Encode("path", accountName),
  4382  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4383  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4384  	}
  4385  
  4386  	const APIVersion = "2015-04-08"
  4387  	queryParameters := map[string]interface{}{
  4388  		"api-version": APIVersion,
  4389  	}
  4390  
  4391  	preparer := autorest.CreatePreparer(
  4392  		autorest.AsPost(),
  4393  		autorest.WithBaseURL(client.BaseURI),
  4394  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/listConnectionStrings", pathParameters),
  4395  		autorest.WithQueryParameters(queryParameters))
  4396  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4397  }
  4398  
  4399  // ListConnectionStringsSender sends the ListConnectionStrings request. The method will close the
  4400  // http.Response Body if it receives an error.
  4401  func (client DatabaseAccountsClient) ListConnectionStringsSender(req *http.Request) (*http.Response, error) {
  4402  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4403  }
  4404  
  4405  // ListConnectionStringsResponder handles the response to the ListConnectionStrings request. The method always
  4406  // closes the http.Response Body.
  4407  func (client DatabaseAccountsClient) ListConnectionStringsResponder(resp *http.Response) (result DatabaseAccountListConnectionStringsResult, err error) {
  4408  	err = autorest.Respond(
  4409  		resp,
  4410  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4411  		autorest.ByUnmarshallingJSON(&result),
  4412  		autorest.ByClosing())
  4413  	result.Response = autorest.Response{Response: resp}
  4414  	return
  4415  }
  4416  
  4417  // ListGremlinDatabases lists the Gremlin databases under an existing Azure Cosmos DB database account.
  4418  // Parameters:
  4419  // resourceGroupName - name of an Azure resource group.
  4420  // accountName - cosmos DB database account name.
  4421  func (client DatabaseAccountsClient) ListGremlinDatabases(ctx context.Context, resourceGroupName string, accountName string) (result GremlinDatabaseListResult, err error) {
  4422  	if tracing.IsEnabled() {
  4423  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListGremlinDatabases")
  4424  		defer func() {
  4425  			sc := -1
  4426  			if result.Response.Response != nil {
  4427  				sc = result.Response.Response.StatusCode
  4428  			}
  4429  			tracing.EndSpan(ctx, sc, err)
  4430  		}()
  4431  	}
  4432  	if err := validation.Validate([]validation.Validation{
  4433  		{TargetValue: resourceGroupName,
  4434  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4435  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4436  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4437  		{TargetValue: accountName,
  4438  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4439  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4440  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4441  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListGremlinDatabases", err.Error())
  4442  	}
  4443  
  4444  	req, err := client.ListGremlinDatabasesPreparer(ctx, resourceGroupName, accountName)
  4445  	if err != nil {
  4446  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinDatabases", nil, "Failure preparing request")
  4447  		return
  4448  	}
  4449  
  4450  	resp, err := client.ListGremlinDatabasesSender(req)
  4451  	if err != nil {
  4452  		result.Response = autorest.Response{Response: resp}
  4453  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinDatabases", resp, "Failure sending request")
  4454  		return
  4455  	}
  4456  
  4457  	result, err = client.ListGremlinDatabasesResponder(resp)
  4458  	if err != nil {
  4459  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinDatabases", resp, "Failure responding to request")
  4460  		return
  4461  	}
  4462  
  4463  	return
  4464  }
  4465  
  4466  // ListGremlinDatabasesPreparer prepares the ListGremlinDatabases request.
  4467  func (client DatabaseAccountsClient) ListGremlinDatabasesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  4468  	pathParameters := map[string]interface{}{
  4469  		"accountName":       autorest.Encode("path", accountName),
  4470  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4471  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4472  	}
  4473  
  4474  	const APIVersion = "2015-04-08"
  4475  	queryParameters := map[string]interface{}{
  4476  		"api-version": APIVersion,
  4477  	}
  4478  
  4479  	preparer := autorest.CreatePreparer(
  4480  		autorest.AsGet(),
  4481  		autorest.WithBaseURL(client.BaseURI),
  4482  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases", pathParameters),
  4483  		autorest.WithQueryParameters(queryParameters))
  4484  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4485  }
  4486  
  4487  // ListGremlinDatabasesSender sends the ListGremlinDatabases request. The method will close the
  4488  // http.Response Body if it receives an error.
  4489  func (client DatabaseAccountsClient) ListGremlinDatabasesSender(req *http.Request) (*http.Response, error) {
  4490  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4491  }
  4492  
  4493  // ListGremlinDatabasesResponder handles the response to the ListGremlinDatabases request. The method always
  4494  // closes the http.Response Body.
  4495  func (client DatabaseAccountsClient) ListGremlinDatabasesResponder(resp *http.Response) (result GremlinDatabaseListResult, err error) {
  4496  	err = autorest.Respond(
  4497  		resp,
  4498  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4499  		autorest.ByUnmarshallingJSON(&result),
  4500  		autorest.ByClosing())
  4501  	result.Response = autorest.Response{Response: resp}
  4502  	return
  4503  }
  4504  
  4505  // ListGremlinGraphs lists the Gremlin graph under an existing Azure Cosmos DB database account.
  4506  // Parameters:
  4507  // resourceGroupName - name of an Azure resource group.
  4508  // accountName - cosmos DB database account name.
  4509  // databaseName - cosmos DB database name.
  4510  func (client DatabaseAccountsClient) ListGremlinGraphs(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result GremlinGraphListResult, err error) {
  4511  	if tracing.IsEnabled() {
  4512  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListGremlinGraphs")
  4513  		defer func() {
  4514  			sc := -1
  4515  			if result.Response.Response != nil {
  4516  				sc = result.Response.Response.StatusCode
  4517  			}
  4518  			tracing.EndSpan(ctx, sc, err)
  4519  		}()
  4520  	}
  4521  	if err := validation.Validate([]validation.Validation{
  4522  		{TargetValue: resourceGroupName,
  4523  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4524  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4525  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4526  		{TargetValue: accountName,
  4527  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4528  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4529  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4530  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListGremlinGraphs", err.Error())
  4531  	}
  4532  
  4533  	req, err := client.ListGremlinGraphsPreparer(ctx, resourceGroupName, accountName, databaseName)
  4534  	if err != nil {
  4535  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinGraphs", nil, "Failure preparing request")
  4536  		return
  4537  	}
  4538  
  4539  	resp, err := client.ListGremlinGraphsSender(req)
  4540  	if err != nil {
  4541  		result.Response = autorest.Response{Response: resp}
  4542  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinGraphs", resp, "Failure sending request")
  4543  		return
  4544  	}
  4545  
  4546  	result, err = client.ListGremlinGraphsResponder(resp)
  4547  	if err != nil {
  4548  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListGremlinGraphs", resp, "Failure responding to request")
  4549  		return
  4550  	}
  4551  
  4552  	return
  4553  }
  4554  
  4555  // ListGremlinGraphsPreparer prepares the ListGremlinGraphs request.
  4556  func (client DatabaseAccountsClient) ListGremlinGraphsPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  4557  	pathParameters := map[string]interface{}{
  4558  		"accountName":       autorest.Encode("path", accountName),
  4559  		"databaseName":      autorest.Encode("path", databaseName),
  4560  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4561  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4562  	}
  4563  
  4564  	const APIVersion = "2015-04-08"
  4565  	queryParameters := map[string]interface{}{
  4566  		"api-version": APIVersion,
  4567  	}
  4568  
  4569  	preparer := autorest.CreatePreparer(
  4570  		autorest.AsGet(),
  4571  		autorest.WithBaseURL(client.BaseURI),
  4572  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs", pathParameters),
  4573  		autorest.WithQueryParameters(queryParameters))
  4574  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4575  }
  4576  
  4577  // ListGremlinGraphsSender sends the ListGremlinGraphs request. The method will close the
  4578  // http.Response Body if it receives an error.
  4579  func (client DatabaseAccountsClient) ListGremlinGraphsSender(req *http.Request) (*http.Response, error) {
  4580  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4581  }
  4582  
  4583  // ListGremlinGraphsResponder handles the response to the ListGremlinGraphs request. The method always
  4584  // closes the http.Response Body.
  4585  func (client DatabaseAccountsClient) ListGremlinGraphsResponder(resp *http.Response) (result GremlinGraphListResult, err error) {
  4586  	err = autorest.Respond(
  4587  		resp,
  4588  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4589  		autorest.ByUnmarshallingJSON(&result),
  4590  		autorest.ByClosing())
  4591  	result.Response = autorest.Response{Response: resp}
  4592  	return
  4593  }
  4594  
  4595  // ListKeys lists the access keys for the specified Azure Cosmos DB database account.
  4596  // Parameters:
  4597  // resourceGroupName - name of an Azure resource group.
  4598  // accountName - cosmos DB database account name.
  4599  func (client DatabaseAccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListKeysResult, err error) {
  4600  	if tracing.IsEnabled() {
  4601  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListKeys")
  4602  		defer func() {
  4603  			sc := -1
  4604  			if result.Response.Response != nil {
  4605  				sc = result.Response.Response.StatusCode
  4606  			}
  4607  			tracing.EndSpan(ctx, sc, err)
  4608  		}()
  4609  	}
  4610  	if err := validation.Validate([]validation.Validation{
  4611  		{TargetValue: resourceGroupName,
  4612  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4613  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4614  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4615  		{TargetValue: accountName,
  4616  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4617  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4618  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4619  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListKeys", err.Error())
  4620  	}
  4621  
  4622  	req, err := client.ListKeysPreparer(ctx, resourceGroupName, accountName)
  4623  	if err != nil {
  4624  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", nil, "Failure preparing request")
  4625  		return
  4626  	}
  4627  
  4628  	resp, err := client.ListKeysSender(req)
  4629  	if err != nil {
  4630  		result.Response = autorest.Response{Response: resp}
  4631  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", resp, "Failure sending request")
  4632  		return
  4633  	}
  4634  
  4635  	result, err = client.ListKeysResponder(resp)
  4636  	if err != nil {
  4637  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", resp, "Failure responding to request")
  4638  		return
  4639  	}
  4640  
  4641  	return
  4642  }
  4643  
  4644  // ListKeysPreparer prepares the ListKeys request.
  4645  func (client DatabaseAccountsClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  4646  	pathParameters := map[string]interface{}{
  4647  		"accountName":       autorest.Encode("path", accountName),
  4648  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4649  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4650  	}
  4651  
  4652  	const APIVersion = "2015-04-08"
  4653  	queryParameters := map[string]interface{}{
  4654  		"api-version": APIVersion,
  4655  	}
  4656  
  4657  	preparer := autorest.CreatePreparer(
  4658  		autorest.AsPost(),
  4659  		autorest.WithBaseURL(client.BaseURI),
  4660  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/listKeys", pathParameters),
  4661  		autorest.WithQueryParameters(queryParameters))
  4662  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4663  }
  4664  
  4665  // ListKeysSender sends the ListKeys request. The method will close the
  4666  // http.Response Body if it receives an error.
  4667  func (client DatabaseAccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) {
  4668  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4669  }
  4670  
  4671  // ListKeysResponder handles the response to the ListKeys request. The method always
  4672  // closes the http.Response Body.
  4673  func (client DatabaseAccountsClient) ListKeysResponder(resp *http.Response) (result DatabaseAccountListKeysResult, err error) {
  4674  	err = autorest.Respond(
  4675  		resp,
  4676  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4677  		autorest.ByUnmarshallingJSON(&result),
  4678  		autorest.ByClosing())
  4679  	result.Response = autorest.Response{Response: resp}
  4680  	return
  4681  }
  4682  
  4683  // ListMetricDefinitions retrieves metric definitions for the given database account.
  4684  // Parameters:
  4685  // resourceGroupName - name of an Azure resource group.
  4686  // accountName - cosmos DB database account name.
  4687  func (client DatabaseAccountsClient) ListMetricDefinitions(ctx context.Context, resourceGroupName string, accountName string) (result MetricDefinitionsListResult, err error) {
  4688  	if tracing.IsEnabled() {
  4689  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMetricDefinitions")
  4690  		defer func() {
  4691  			sc := -1
  4692  			if result.Response.Response != nil {
  4693  				sc = result.Response.Response.StatusCode
  4694  			}
  4695  			tracing.EndSpan(ctx, sc, err)
  4696  		}()
  4697  	}
  4698  	if err := validation.Validate([]validation.Validation{
  4699  		{TargetValue: resourceGroupName,
  4700  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4701  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4702  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4703  		{TargetValue: accountName,
  4704  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4705  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4706  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4707  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMetricDefinitions", err.Error())
  4708  	}
  4709  
  4710  	req, err := client.ListMetricDefinitionsPreparer(ctx, resourceGroupName, accountName)
  4711  	if err != nil {
  4712  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", nil, "Failure preparing request")
  4713  		return
  4714  	}
  4715  
  4716  	resp, err := client.ListMetricDefinitionsSender(req)
  4717  	if err != nil {
  4718  		result.Response = autorest.Response{Response: resp}
  4719  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", resp, "Failure sending request")
  4720  		return
  4721  	}
  4722  
  4723  	result, err = client.ListMetricDefinitionsResponder(resp)
  4724  	if err != nil {
  4725  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", resp, "Failure responding to request")
  4726  		return
  4727  	}
  4728  
  4729  	return
  4730  }
  4731  
  4732  // ListMetricDefinitionsPreparer prepares the ListMetricDefinitions request.
  4733  func (client DatabaseAccountsClient) ListMetricDefinitionsPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  4734  	pathParameters := map[string]interface{}{
  4735  		"accountName":       autorest.Encode("path", accountName),
  4736  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4737  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4738  	}
  4739  
  4740  	const APIVersion = "2015-04-08"
  4741  	queryParameters := map[string]interface{}{
  4742  		"api-version": APIVersion,
  4743  	}
  4744  
  4745  	preparer := autorest.CreatePreparer(
  4746  		autorest.AsGet(),
  4747  		autorest.WithBaseURL(client.BaseURI),
  4748  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/metricDefinitions", pathParameters),
  4749  		autorest.WithQueryParameters(queryParameters))
  4750  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4751  }
  4752  
  4753  // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the
  4754  // http.Response Body if it receives an error.
  4755  func (client DatabaseAccountsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
  4756  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4757  }
  4758  
  4759  // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always
  4760  // closes the http.Response Body.
  4761  func (client DatabaseAccountsClient) ListMetricDefinitionsResponder(resp *http.Response) (result MetricDefinitionsListResult, err error) {
  4762  	err = autorest.Respond(
  4763  		resp,
  4764  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4765  		autorest.ByUnmarshallingJSON(&result),
  4766  		autorest.ByClosing())
  4767  	result.Response = autorest.Response{Response: resp}
  4768  	return
  4769  }
  4770  
  4771  // ListMetrics retrieves the metrics determined by the given filter for the given database account.
  4772  // Parameters:
  4773  // resourceGroupName - name of an Azure resource group.
  4774  // accountName - cosmos DB database account name.
  4775  // filter - an OData filter expression that describes a subset of metrics to return. The parameters that can be
  4776  // filtered are name.value (name of the metric, can have an or of multiple names), startTime, endTime, and
  4777  // timeGrain. The supported operator is eq.
  4778  func (client DatabaseAccountsClient) ListMetrics(ctx context.Context, resourceGroupName string, accountName string, filter string) (result MetricListResult, err error) {
  4779  	if tracing.IsEnabled() {
  4780  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMetrics")
  4781  		defer func() {
  4782  			sc := -1
  4783  			if result.Response.Response != nil {
  4784  				sc = result.Response.Response.StatusCode
  4785  			}
  4786  			tracing.EndSpan(ctx, sc, err)
  4787  		}()
  4788  	}
  4789  	if err := validation.Validate([]validation.Validation{
  4790  		{TargetValue: resourceGroupName,
  4791  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4792  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4793  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4794  		{TargetValue: accountName,
  4795  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4796  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4797  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4798  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMetrics", err.Error())
  4799  	}
  4800  
  4801  	req, err := client.ListMetricsPreparer(ctx, resourceGroupName, accountName, filter)
  4802  	if err != nil {
  4803  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", nil, "Failure preparing request")
  4804  		return
  4805  	}
  4806  
  4807  	resp, err := client.ListMetricsSender(req)
  4808  	if err != nil {
  4809  		result.Response = autorest.Response{Response: resp}
  4810  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", resp, "Failure sending request")
  4811  		return
  4812  	}
  4813  
  4814  	result, err = client.ListMetricsResponder(resp)
  4815  	if err != nil {
  4816  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", resp, "Failure responding to request")
  4817  		return
  4818  	}
  4819  
  4820  	return
  4821  }
  4822  
  4823  // ListMetricsPreparer prepares the ListMetrics request.
  4824  func (client DatabaseAccountsClient) ListMetricsPreparer(ctx context.Context, resourceGroupName string, accountName string, filter string) (*http.Request, error) {
  4825  	pathParameters := map[string]interface{}{
  4826  		"accountName":       autorest.Encode("path", accountName),
  4827  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4828  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4829  	}
  4830  
  4831  	const APIVersion = "2015-04-08"
  4832  	queryParameters := map[string]interface{}{
  4833  		"$filter":     autorest.Encode("query", filter),
  4834  		"api-version": APIVersion,
  4835  	}
  4836  
  4837  	preparer := autorest.CreatePreparer(
  4838  		autorest.AsGet(),
  4839  		autorest.WithBaseURL(client.BaseURI),
  4840  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/metrics", pathParameters),
  4841  		autorest.WithQueryParameters(queryParameters))
  4842  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4843  }
  4844  
  4845  // ListMetricsSender sends the ListMetrics request. The method will close the
  4846  // http.Response Body if it receives an error.
  4847  func (client DatabaseAccountsClient) ListMetricsSender(req *http.Request) (*http.Response, error) {
  4848  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4849  }
  4850  
  4851  // ListMetricsResponder handles the response to the ListMetrics request. The method always
  4852  // closes the http.Response Body.
  4853  func (client DatabaseAccountsClient) ListMetricsResponder(resp *http.Response) (result MetricListResult, err error) {
  4854  	err = autorest.Respond(
  4855  		resp,
  4856  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4857  		autorest.ByUnmarshallingJSON(&result),
  4858  		autorest.ByClosing())
  4859  	result.Response = autorest.Response{Response: resp}
  4860  	return
  4861  }
  4862  
  4863  // ListMongoDBCollections lists the MongoDB collection under an existing Azure Cosmos DB database account.
  4864  // Parameters:
  4865  // resourceGroupName - name of an Azure resource group.
  4866  // accountName - cosmos DB database account name.
  4867  // databaseName - cosmos DB database name.
  4868  func (client DatabaseAccountsClient) ListMongoDBCollections(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result MongoDBCollectionListResult, err error) {
  4869  	if tracing.IsEnabled() {
  4870  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMongoDBCollections")
  4871  		defer func() {
  4872  			sc := -1
  4873  			if result.Response.Response != nil {
  4874  				sc = result.Response.Response.StatusCode
  4875  			}
  4876  			tracing.EndSpan(ctx, sc, err)
  4877  		}()
  4878  	}
  4879  	if err := validation.Validate([]validation.Validation{
  4880  		{TargetValue: resourceGroupName,
  4881  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4882  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4883  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4884  		{TargetValue: accountName,
  4885  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4886  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4887  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4888  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMongoDBCollections", err.Error())
  4889  	}
  4890  
  4891  	req, err := client.ListMongoDBCollectionsPreparer(ctx, resourceGroupName, accountName, databaseName)
  4892  	if err != nil {
  4893  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBCollections", nil, "Failure preparing request")
  4894  		return
  4895  	}
  4896  
  4897  	resp, err := client.ListMongoDBCollectionsSender(req)
  4898  	if err != nil {
  4899  		result.Response = autorest.Response{Response: resp}
  4900  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBCollections", resp, "Failure sending request")
  4901  		return
  4902  	}
  4903  
  4904  	result, err = client.ListMongoDBCollectionsResponder(resp)
  4905  	if err != nil {
  4906  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBCollections", resp, "Failure responding to request")
  4907  		return
  4908  	}
  4909  
  4910  	return
  4911  }
  4912  
  4913  // ListMongoDBCollectionsPreparer prepares the ListMongoDBCollections request.
  4914  func (client DatabaseAccountsClient) ListMongoDBCollectionsPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  4915  	pathParameters := map[string]interface{}{
  4916  		"accountName":       autorest.Encode("path", accountName),
  4917  		"databaseName":      autorest.Encode("path", databaseName),
  4918  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  4919  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  4920  	}
  4921  
  4922  	const APIVersion = "2015-04-08"
  4923  	queryParameters := map[string]interface{}{
  4924  		"api-version": APIVersion,
  4925  	}
  4926  
  4927  	preparer := autorest.CreatePreparer(
  4928  		autorest.AsGet(),
  4929  		autorest.WithBaseURL(client.BaseURI),
  4930  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections", pathParameters),
  4931  		autorest.WithQueryParameters(queryParameters))
  4932  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  4933  }
  4934  
  4935  // ListMongoDBCollectionsSender sends the ListMongoDBCollections request. The method will close the
  4936  // http.Response Body if it receives an error.
  4937  func (client DatabaseAccountsClient) ListMongoDBCollectionsSender(req *http.Request) (*http.Response, error) {
  4938  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  4939  }
  4940  
  4941  // ListMongoDBCollectionsResponder handles the response to the ListMongoDBCollections request. The method always
  4942  // closes the http.Response Body.
  4943  func (client DatabaseAccountsClient) ListMongoDBCollectionsResponder(resp *http.Response) (result MongoDBCollectionListResult, err error) {
  4944  	err = autorest.Respond(
  4945  		resp,
  4946  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  4947  		autorest.ByUnmarshallingJSON(&result),
  4948  		autorest.ByClosing())
  4949  	result.Response = autorest.Response{Response: resp}
  4950  	return
  4951  }
  4952  
  4953  // ListMongoDBDatabases lists the MongoDB databases under an existing Azure Cosmos DB database account.
  4954  // Parameters:
  4955  // resourceGroupName - name of an Azure resource group.
  4956  // accountName - cosmos DB database account name.
  4957  func (client DatabaseAccountsClient) ListMongoDBDatabases(ctx context.Context, resourceGroupName string, accountName string) (result MongoDBDatabaseListResult, err error) {
  4958  	if tracing.IsEnabled() {
  4959  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMongoDBDatabases")
  4960  		defer func() {
  4961  			sc := -1
  4962  			if result.Response.Response != nil {
  4963  				sc = result.Response.Response.StatusCode
  4964  			}
  4965  			tracing.EndSpan(ctx, sc, err)
  4966  		}()
  4967  	}
  4968  	if err := validation.Validate([]validation.Validation{
  4969  		{TargetValue: resourceGroupName,
  4970  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  4971  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  4972  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  4973  		{TargetValue: accountName,
  4974  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  4975  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  4976  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  4977  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMongoDBDatabases", err.Error())
  4978  	}
  4979  
  4980  	req, err := client.ListMongoDBDatabasesPreparer(ctx, resourceGroupName, accountName)
  4981  	if err != nil {
  4982  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBDatabases", nil, "Failure preparing request")
  4983  		return
  4984  	}
  4985  
  4986  	resp, err := client.ListMongoDBDatabasesSender(req)
  4987  	if err != nil {
  4988  		result.Response = autorest.Response{Response: resp}
  4989  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBDatabases", resp, "Failure sending request")
  4990  		return
  4991  	}
  4992  
  4993  	result, err = client.ListMongoDBDatabasesResponder(resp)
  4994  	if err != nil {
  4995  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMongoDBDatabases", resp, "Failure responding to request")
  4996  		return
  4997  	}
  4998  
  4999  	return
  5000  }
  5001  
  5002  // ListMongoDBDatabasesPreparer prepares the ListMongoDBDatabases request.
  5003  func (client DatabaseAccountsClient) ListMongoDBDatabasesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  5004  	pathParameters := map[string]interface{}{
  5005  		"accountName":       autorest.Encode("path", accountName),
  5006  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5007  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5008  	}
  5009  
  5010  	const APIVersion = "2015-04-08"
  5011  	queryParameters := map[string]interface{}{
  5012  		"api-version": APIVersion,
  5013  	}
  5014  
  5015  	preparer := autorest.CreatePreparer(
  5016  		autorest.AsGet(),
  5017  		autorest.WithBaseURL(client.BaseURI),
  5018  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases", pathParameters),
  5019  		autorest.WithQueryParameters(queryParameters))
  5020  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5021  }
  5022  
  5023  // ListMongoDBDatabasesSender sends the ListMongoDBDatabases request. The method will close the
  5024  // http.Response Body if it receives an error.
  5025  func (client DatabaseAccountsClient) ListMongoDBDatabasesSender(req *http.Request) (*http.Response, error) {
  5026  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5027  }
  5028  
  5029  // ListMongoDBDatabasesResponder handles the response to the ListMongoDBDatabases request. The method always
  5030  // closes the http.Response Body.
  5031  func (client DatabaseAccountsClient) ListMongoDBDatabasesResponder(resp *http.Response) (result MongoDBDatabaseListResult, err error) {
  5032  	err = autorest.Respond(
  5033  		resp,
  5034  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5035  		autorest.ByUnmarshallingJSON(&result),
  5036  		autorest.ByClosing())
  5037  	result.Response = autorest.Response{Response: resp}
  5038  	return
  5039  }
  5040  
  5041  // ListReadOnlyKeys lists the read-only access keys for the specified Azure Cosmos DB database account.
  5042  // Parameters:
  5043  // resourceGroupName - name of an Azure resource group.
  5044  // accountName - cosmos DB database account name.
  5045  func (client DatabaseAccountsClient) ListReadOnlyKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  5046  	if tracing.IsEnabled() {
  5047  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListReadOnlyKeys")
  5048  		defer func() {
  5049  			sc := -1
  5050  			if result.Response.Response != nil {
  5051  				sc = result.Response.Response.StatusCode
  5052  			}
  5053  			tracing.EndSpan(ctx, sc, err)
  5054  		}()
  5055  	}
  5056  	if err := validation.Validate([]validation.Validation{
  5057  		{TargetValue: resourceGroupName,
  5058  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5059  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5060  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5061  		{TargetValue: accountName,
  5062  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5063  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5064  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5065  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", err.Error())
  5066  	}
  5067  
  5068  	req, err := client.ListReadOnlyKeysPreparer(ctx, resourceGroupName, accountName)
  5069  	if err != nil {
  5070  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", nil, "Failure preparing request")
  5071  		return
  5072  	}
  5073  
  5074  	resp, err := client.ListReadOnlyKeysSender(req)
  5075  	if err != nil {
  5076  		result.Response = autorest.Response{Response: resp}
  5077  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", resp, "Failure sending request")
  5078  		return
  5079  	}
  5080  
  5081  	result, err = client.ListReadOnlyKeysResponder(resp)
  5082  	if err != nil {
  5083  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", resp, "Failure responding to request")
  5084  		return
  5085  	}
  5086  
  5087  	return
  5088  }
  5089  
  5090  // ListReadOnlyKeysPreparer prepares the ListReadOnlyKeys request.
  5091  func (client DatabaseAccountsClient) ListReadOnlyKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  5092  	pathParameters := map[string]interface{}{
  5093  		"accountName":       autorest.Encode("path", accountName),
  5094  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5095  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5096  	}
  5097  
  5098  	const APIVersion = "2015-04-08"
  5099  	queryParameters := map[string]interface{}{
  5100  		"api-version": APIVersion,
  5101  	}
  5102  
  5103  	preparer := autorest.CreatePreparer(
  5104  		autorest.AsPost(),
  5105  		autorest.WithBaseURL(client.BaseURI),
  5106  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/readonlykeys", pathParameters),
  5107  		autorest.WithQueryParameters(queryParameters))
  5108  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5109  }
  5110  
  5111  // ListReadOnlyKeysSender sends the ListReadOnlyKeys request. The method will close the
  5112  // http.Response Body if it receives an error.
  5113  func (client DatabaseAccountsClient) ListReadOnlyKeysSender(req *http.Request) (*http.Response, error) {
  5114  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5115  }
  5116  
  5117  // ListReadOnlyKeysResponder handles the response to the ListReadOnlyKeys request. The method always
  5118  // closes the http.Response Body.
  5119  func (client DatabaseAccountsClient) ListReadOnlyKeysResponder(resp *http.Response) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  5120  	err = autorest.Respond(
  5121  		resp,
  5122  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5123  		autorest.ByUnmarshallingJSON(&result),
  5124  		autorest.ByClosing())
  5125  	result.Response = autorest.Response{Response: resp}
  5126  	return
  5127  }
  5128  
  5129  // ListSQLContainers lists the SQL container under an existing Azure Cosmos DB database account.
  5130  // Parameters:
  5131  // resourceGroupName - name of an Azure resource group.
  5132  // accountName - cosmos DB database account name.
  5133  // databaseName - cosmos DB database name.
  5134  func (client DatabaseAccountsClient) ListSQLContainers(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (result SQLContainerListResult, err error) {
  5135  	if tracing.IsEnabled() {
  5136  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListSQLContainers")
  5137  		defer func() {
  5138  			sc := -1
  5139  			if result.Response.Response != nil {
  5140  				sc = result.Response.Response.StatusCode
  5141  			}
  5142  			tracing.EndSpan(ctx, sc, err)
  5143  		}()
  5144  	}
  5145  	if err := validation.Validate([]validation.Validation{
  5146  		{TargetValue: resourceGroupName,
  5147  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5148  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5149  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5150  		{TargetValue: accountName,
  5151  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5152  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5153  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5154  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListSQLContainers", err.Error())
  5155  	}
  5156  
  5157  	req, err := client.ListSQLContainersPreparer(ctx, resourceGroupName, accountName, databaseName)
  5158  	if err != nil {
  5159  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLContainers", nil, "Failure preparing request")
  5160  		return
  5161  	}
  5162  
  5163  	resp, err := client.ListSQLContainersSender(req)
  5164  	if err != nil {
  5165  		result.Response = autorest.Response{Response: resp}
  5166  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLContainers", resp, "Failure sending request")
  5167  		return
  5168  	}
  5169  
  5170  	result, err = client.ListSQLContainersResponder(resp)
  5171  	if err != nil {
  5172  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLContainers", resp, "Failure responding to request")
  5173  		return
  5174  	}
  5175  
  5176  	return
  5177  }
  5178  
  5179  // ListSQLContainersPreparer prepares the ListSQLContainers request.
  5180  func (client DatabaseAccountsClient) ListSQLContainersPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string) (*http.Request, error) {
  5181  	pathParameters := map[string]interface{}{
  5182  		"accountName":       autorest.Encode("path", accountName),
  5183  		"databaseName":      autorest.Encode("path", databaseName),
  5184  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5185  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5186  	}
  5187  
  5188  	const APIVersion = "2015-04-08"
  5189  	queryParameters := map[string]interface{}{
  5190  		"api-version": APIVersion,
  5191  	}
  5192  
  5193  	preparer := autorest.CreatePreparer(
  5194  		autorest.AsGet(),
  5195  		autorest.WithBaseURL(client.BaseURI),
  5196  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers", pathParameters),
  5197  		autorest.WithQueryParameters(queryParameters))
  5198  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5199  }
  5200  
  5201  // ListSQLContainersSender sends the ListSQLContainers request. The method will close the
  5202  // http.Response Body if it receives an error.
  5203  func (client DatabaseAccountsClient) ListSQLContainersSender(req *http.Request) (*http.Response, error) {
  5204  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5205  }
  5206  
  5207  // ListSQLContainersResponder handles the response to the ListSQLContainers request. The method always
  5208  // closes the http.Response Body.
  5209  func (client DatabaseAccountsClient) ListSQLContainersResponder(resp *http.Response) (result SQLContainerListResult, err error) {
  5210  	err = autorest.Respond(
  5211  		resp,
  5212  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5213  		autorest.ByUnmarshallingJSON(&result),
  5214  		autorest.ByClosing())
  5215  	result.Response = autorest.Response{Response: resp}
  5216  	return
  5217  }
  5218  
  5219  // ListSQLDatabases lists the SQL databases under an existing Azure Cosmos DB database account.
  5220  // Parameters:
  5221  // resourceGroupName - name of an Azure resource group.
  5222  // accountName - cosmos DB database account name.
  5223  func (client DatabaseAccountsClient) ListSQLDatabases(ctx context.Context, resourceGroupName string, accountName string) (result SQLDatabaseListResult, err error) {
  5224  	if tracing.IsEnabled() {
  5225  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListSQLDatabases")
  5226  		defer func() {
  5227  			sc := -1
  5228  			if result.Response.Response != nil {
  5229  				sc = result.Response.Response.StatusCode
  5230  			}
  5231  			tracing.EndSpan(ctx, sc, err)
  5232  		}()
  5233  	}
  5234  	if err := validation.Validate([]validation.Validation{
  5235  		{TargetValue: resourceGroupName,
  5236  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5237  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5238  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5239  		{TargetValue: accountName,
  5240  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5241  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5242  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5243  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListSQLDatabases", err.Error())
  5244  	}
  5245  
  5246  	req, err := client.ListSQLDatabasesPreparer(ctx, resourceGroupName, accountName)
  5247  	if err != nil {
  5248  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLDatabases", nil, "Failure preparing request")
  5249  		return
  5250  	}
  5251  
  5252  	resp, err := client.ListSQLDatabasesSender(req)
  5253  	if err != nil {
  5254  		result.Response = autorest.Response{Response: resp}
  5255  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLDatabases", resp, "Failure sending request")
  5256  		return
  5257  	}
  5258  
  5259  	result, err = client.ListSQLDatabasesResponder(resp)
  5260  	if err != nil {
  5261  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListSQLDatabases", resp, "Failure responding to request")
  5262  		return
  5263  	}
  5264  
  5265  	return
  5266  }
  5267  
  5268  // ListSQLDatabasesPreparer prepares the ListSQLDatabases request.
  5269  func (client DatabaseAccountsClient) ListSQLDatabasesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  5270  	pathParameters := map[string]interface{}{
  5271  		"accountName":       autorest.Encode("path", accountName),
  5272  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5273  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5274  	}
  5275  
  5276  	const APIVersion = "2015-04-08"
  5277  	queryParameters := map[string]interface{}{
  5278  		"api-version": APIVersion,
  5279  	}
  5280  
  5281  	preparer := autorest.CreatePreparer(
  5282  		autorest.AsGet(),
  5283  		autorest.WithBaseURL(client.BaseURI),
  5284  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases", pathParameters),
  5285  		autorest.WithQueryParameters(queryParameters))
  5286  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5287  }
  5288  
  5289  // ListSQLDatabasesSender sends the ListSQLDatabases request. The method will close the
  5290  // http.Response Body if it receives an error.
  5291  func (client DatabaseAccountsClient) ListSQLDatabasesSender(req *http.Request) (*http.Response, error) {
  5292  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5293  }
  5294  
  5295  // ListSQLDatabasesResponder handles the response to the ListSQLDatabases request. The method always
  5296  // closes the http.Response Body.
  5297  func (client DatabaseAccountsClient) ListSQLDatabasesResponder(resp *http.Response) (result SQLDatabaseListResult, err error) {
  5298  	err = autorest.Respond(
  5299  		resp,
  5300  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5301  		autorest.ByUnmarshallingJSON(&result),
  5302  		autorest.ByClosing())
  5303  	result.Response = autorest.Response{Response: resp}
  5304  	return
  5305  }
  5306  
  5307  // ListTables lists the Tables under an existing Azure Cosmos DB database account.
  5308  // Parameters:
  5309  // resourceGroupName - name of an Azure resource group.
  5310  // accountName - cosmos DB database account name.
  5311  func (client DatabaseAccountsClient) ListTables(ctx context.Context, resourceGroupName string, accountName string) (result TableListResult, err error) {
  5312  	if tracing.IsEnabled() {
  5313  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListTables")
  5314  		defer func() {
  5315  			sc := -1
  5316  			if result.Response.Response != nil {
  5317  				sc = result.Response.Response.StatusCode
  5318  			}
  5319  			tracing.EndSpan(ctx, sc, err)
  5320  		}()
  5321  	}
  5322  	if err := validation.Validate([]validation.Validation{
  5323  		{TargetValue: resourceGroupName,
  5324  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5325  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5326  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5327  		{TargetValue: accountName,
  5328  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5329  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5330  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5331  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListTables", err.Error())
  5332  	}
  5333  
  5334  	req, err := client.ListTablesPreparer(ctx, resourceGroupName, accountName)
  5335  	if err != nil {
  5336  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListTables", nil, "Failure preparing request")
  5337  		return
  5338  	}
  5339  
  5340  	resp, err := client.ListTablesSender(req)
  5341  	if err != nil {
  5342  		result.Response = autorest.Response{Response: resp}
  5343  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListTables", resp, "Failure sending request")
  5344  		return
  5345  	}
  5346  
  5347  	result, err = client.ListTablesResponder(resp)
  5348  	if err != nil {
  5349  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListTables", resp, "Failure responding to request")
  5350  		return
  5351  	}
  5352  
  5353  	return
  5354  }
  5355  
  5356  // ListTablesPreparer prepares the ListTables request.
  5357  func (client DatabaseAccountsClient) ListTablesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  5358  	pathParameters := map[string]interface{}{
  5359  		"accountName":       autorest.Encode("path", accountName),
  5360  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5361  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5362  	}
  5363  
  5364  	const APIVersion = "2015-04-08"
  5365  	queryParameters := map[string]interface{}{
  5366  		"api-version": APIVersion,
  5367  	}
  5368  
  5369  	preparer := autorest.CreatePreparer(
  5370  		autorest.AsGet(),
  5371  		autorest.WithBaseURL(client.BaseURI),
  5372  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables", pathParameters),
  5373  		autorest.WithQueryParameters(queryParameters))
  5374  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5375  }
  5376  
  5377  // ListTablesSender sends the ListTables request. The method will close the
  5378  // http.Response Body if it receives an error.
  5379  func (client DatabaseAccountsClient) ListTablesSender(req *http.Request) (*http.Response, error) {
  5380  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5381  }
  5382  
  5383  // ListTablesResponder handles the response to the ListTables request. The method always
  5384  // closes the http.Response Body.
  5385  func (client DatabaseAccountsClient) ListTablesResponder(resp *http.Response) (result TableListResult, err error) {
  5386  	err = autorest.Respond(
  5387  		resp,
  5388  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5389  		autorest.ByUnmarshallingJSON(&result),
  5390  		autorest.ByClosing())
  5391  	result.Response = autorest.Response{Response: resp}
  5392  	return
  5393  }
  5394  
  5395  // ListUsages retrieves the usages (most recent data) for the given database account.
  5396  // Parameters:
  5397  // resourceGroupName - name of an Azure resource group.
  5398  // accountName - cosmos DB database account name.
  5399  // filter - an OData filter expression that describes a subset of usages to return. The supported parameter is
  5400  // name.value (name of the metric, can have an or of multiple names).
  5401  func (client DatabaseAccountsClient) ListUsages(ctx context.Context, resourceGroupName string, accountName string, filter string) (result UsagesResult, err error) {
  5402  	if tracing.IsEnabled() {
  5403  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListUsages")
  5404  		defer func() {
  5405  			sc := -1
  5406  			if result.Response.Response != nil {
  5407  				sc = result.Response.Response.StatusCode
  5408  			}
  5409  			tracing.EndSpan(ctx, sc, err)
  5410  		}()
  5411  	}
  5412  	if err := validation.Validate([]validation.Validation{
  5413  		{TargetValue: resourceGroupName,
  5414  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5415  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5416  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5417  		{TargetValue: accountName,
  5418  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5419  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5420  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5421  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListUsages", err.Error())
  5422  	}
  5423  
  5424  	req, err := client.ListUsagesPreparer(ctx, resourceGroupName, accountName, filter)
  5425  	if err != nil {
  5426  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", nil, "Failure preparing request")
  5427  		return
  5428  	}
  5429  
  5430  	resp, err := client.ListUsagesSender(req)
  5431  	if err != nil {
  5432  		result.Response = autorest.Response{Response: resp}
  5433  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", resp, "Failure sending request")
  5434  		return
  5435  	}
  5436  
  5437  	result, err = client.ListUsagesResponder(resp)
  5438  	if err != nil {
  5439  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", resp, "Failure responding to request")
  5440  		return
  5441  	}
  5442  
  5443  	return
  5444  }
  5445  
  5446  // ListUsagesPreparer prepares the ListUsages request.
  5447  func (client DatabaseAccountsClient) ListUsagesPreparer(ctx context.Context, resourceGroupName string, accountName string, filter string) (*http.Request, error) {
  5448  	pathParameters := map[string]interface{}{
  5449  		"accountName":       autorest.Encode("path", accountName),
  5450  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5451  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5452  	}
  5453  
  5454  	const APIVersion = "2015-04-08"
  5455  	queryParameters := map[string]interface{}{
  5456  		"api-version": APIVersion,
  5457  	}
  5458  	if len(filter) > 0 {
  5459  		queryParameters["$filter"] = autorest.Encode("query", filter)
  5460  	}
  5461  
  5462  	preparer := autorest.CreatePreparer(
  5463  		autorest.AsGet(),
  5464  		autorest.WithBaseURL(client.BaseURI),
  5465  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/usages", pathParameters),
  5466  		autorest.WithQueryParameters(queryParameters))
  5467  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5468  }
  5469  
  5470  // ListUsagesSender sends the ListUsages request. The method will close the
  5471  // http.Response Body if it receives an error.
  5472  func (client DatabaseAccountsClient) ListUsagesSender(req *http.Request) (*http.Response, error) {
  5473  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5474  }
  5475  
  5476  // ListUsagesResponder handles the response to the ListUsages request. The method always
  5477  // closes the http.Response Body.
  5478  func (client DatabaseAccountsClient) ListUsagesResponder(resp *http.Response) (result UsagesResult, err error) {
  5479  	err = autorest.Respond(
  5480  		resp,
  5481  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5482  		autorest.ByUnmarshallingJSON(&result),
  5483  		autorest.ByClosing())
  5484  	result.Response = autorest.Response{Response: resp}
  5485  	return
  5486  }
  5487  
  5488  // OfflineRegion offline the specified region for the specified Azure Cosmos DB database account.
  5489  // Parameters:
  5490  // resourceGroupName - name of an Azure resource group.
  5491  // accountName - cosmos DB database account name.
  5492  // regionParameterForOffline - cosmos DB region to offline for the database account.
  5493  func (client DatabaseAccountsClient) OfflineRegion(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOffline RegionForOnlineOffline) (result DatabaseAccountsOfflineRegionFuture, err error) {
  5494  	if tracing.IsEnabled() {
  5495  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.OfflineRegion")
  5496  		defer func() {
  5497  			sc := -1
  5498  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5499  				sc = result.FutureAPI.Response().StatusCode
  5500  			}
  5501  			tracing.EndSpan(ctx, sc, err)
  5502  		}()
  5503  	}
  5504  	if err := validation.Validate([]validation.Validation{
  5505  		{TargetValue: resourceGroupName,
  5506  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5507  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5508  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5509  		{TargetValue: accountName,
  5510  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5511  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5512  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  5513  		{TargetValue: regionParameterForOffline,
  5514  			Constraints: []validation.Constraint{{Target: "regionParameterForOffline.Region", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  5515  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "OfflineRegion", err.Error())
  5516  	}
  5517  
  5518  	req, err := client.OfflineRegionPreparer(ctx, resourceGroupName, accountName, regionParameterForOffline)
  5519  	if err != nil {
  5520  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OfflineRegion", nil, "Failure preparing request")
  5521  		return
  5522  	}
  5523  
  5524  	result, err = client.OfflineRegionSender(req)
  5525  	if err != nil {
  5526  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OfflineRegion", result.Response(), "Failure sending request")
  5527  		return
  5528  	}
  5529  
  5530  	return
  5531  }
  5532  
  5533  // OfflineRegionPreparer prepares the OfflineRegion request.
  5534  func (client DatabaseAccountsClient) OfflineRegionPreparer(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOffline RegionForOnlineOffline) (*http.Request, error) {
  5535  	pathParameters := map[string]interface{}{
  5536  		"accountName":       autorest.Encode("path", accountName),
  5537  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5538  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5539  	}
  5540  
  5541  	const APIVersion = "2015-04-08"
  5542  	queryParameters := map[string]interface{}{
  5543  		"api-version": APIVersion,
  5544  	}
  5545  
  5546  	preparer := autorest.CreatePreparer(
  5547  		autorest.AsContentType("application/json; charset=utf-8"),
  5548  		autorest.AsPost(),
  5549  		autorest.WithBaseURL(client.BaseURI),
  5550  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/offlineRegion", pathParameters),
  5551  		autorest.WithJSON(regionParameterForOffline),
  5552  		autorest.WithQueryParameters(queryParameters))
  5553  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5554  }
  5555  
  5556  // OfflineRegionSender sends the OfflineRegion request. The method will close the
  5557  // http.Response Body if it receives an error.
  5558  func (client DatabaseAccountsClient) OfflineRegionSender(req *http.Request) (future DatabaseAccountsOfflineRegionFuture, err error) {
  5559  	var resp *http.Response
  5560  	future.FutureAPI = &azure.Future{}
  5561  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5562  	if err != nil {
  5563  		return
  5564  	}
  5565  	var azf azure.Future
  5566  	azf, err = azure.NewFutureFromResponse(resp)
  5567  	future.FutureAPI = &azf
  5568  	future.Result = future.result
  5569  	return
  5570  }
  5571  
  5572  // OfflineRegionResponder handles the response to the OfflineRegion request. The method always
  5573  // closes the http.Response Body.
  5574  func (client DatabaseAccountsClient) OfflineRegionResponder(resp *http.Response) (result autorest.Response, err error) {
  5575  	err = autorest.Respond(
  5576  		resp,
  5577  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  5578  		autorest.ByClosing())
  5579  	result.Response = resp
  5580  	return
  5581  }
  5582  
  5583  // OnlineRegion online the specified region for the specified Azure Cosmos DB database account.
  5584  // Parameters:
  5585  // resourceGroupName - name of an Azure resource group.
  5586  // accountName - cosmos DB database account name.
  5587  // regionParameterForOnline - cosmos DB region to online for the database account.
  5588  func (client DatabaseAccountsClient) OnlineRegion(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOnline RegionForOnlineOffline) (result DatabaseAccountsOnlineRegionFuture, err error) {
  5589  	if tracing.IsEnabled() {
  5590  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.OnlineRegion")
  5591  		defer func() {
  5592  			sc := -1
  5593  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5594  				sc = result.FutureAPI.Response().StatusCode
  5595  			}
  5596  			tracing.EndSpan(ctx, sc, err)
  5597  		}()
  5598  	}
  5599  	if err := validation.Validate([]validation.Validation{
  5600  		{TargetValue: resourceGroupName,
  5601  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5602  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5603  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5604  		{TargetValue: accountName,
  5605  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5606  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5607  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  5608  		{TargetValue: regionParameterForOnline,
  5609  			Constraints: []validation.Constraint{{Target: "regionParameterForOnline.Region", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  5610  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "OnlineRegion", err.Error())
  5611  	}
  5612  
  5613  	req, err := client.OnlineRegionPreparer(ctx, resourceGroupName, accountName, regionParameterForOnline)
  5614  	if err != nil {
  5615  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OnlineRegion", nil, "Failure preparing request")
  5616  		return
  5617  	}
  5618  
  5619  	result, err = client.OnlineRegionSender(req)
  5620  	if err != nil {
  5621  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OnlineRegion", result.Response(), "Failure sending request")
  5622  		return
  5623  	}
  5624  
  5625  	return
  5626  }
  5627  
  5628  // OnlineRegionPreparer prepares the OnlineRegion request.
  5629  func (client DatabaseAccountsClient) OnlineRegionPreparer(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOnline RegionForOnlineOffline) (*http.Request, error) {
  5630  	pathParameters := map[string]interface{}{
  5631  		"accountName":       autorest.Encode("path", accountName),
  5632  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5633  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5634  	}
  5635  
  5636  	const APIVersion = "2015-04-08"
  5637  	queryParameters := map[string]interface{}{
  5638  		"api-version": APIVersion,
  5639  	}
  5640  
  5641  	preparer := autorest.CreatePreparer(
  5642  		autorest.AsContentType("application/json; charset=utf-8"),
  5643  		autorest.AsPost(),
  5644  		autorest.WithBaseURL(client.BaseURI),
  5645  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/onlineRegion", pathParameters),
  5646  		autorest.WithJSON(regionParameterForOnline),
  5647  		autorest.WithQueryParameters(queryParameters))
  5648  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5649  }
  5650  
  5651  // OnlineRegionSender sends the OnlineRegion request. The method will close the
  5652  // http.Response Body if it receives an error.
  5653  func (client DatabaseAccountsClient) OnlineRegionSender(req *http.Request) (future DatabaseAccountsOnlineRegionFuture, err error) {
  5654  	var resp *http.Response
  5655  	future.FutureAPI = &azure.Future{}
  5656  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5657  	if err != nil {
  5658  		return
  5659  	}
  5660  	var azf azure.Future
  5661  	azf, err = azure.NewFutureFromResponse(resp)
  5662  	future.FutureAPI = &azf
  5663  	future.Result = future.result
  5664  	return
  5665  }
  5666  
  5667  // OnlineRegionResponder handles the response to the OnlineRegion request. The method always
  5668  // closes the http.Response Body.
  5669  func (client DatabaseAccountsClient) OnlineRegionResponder(resp *http.Response) (result autorest.Response, err error) {
  5670  	err = autorest.Respond(
  5671  		resp,
  5672  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  5673  		autorest.ByClosing())
  5674  	result.Response = resp
  5675  	return
  5676  }
  5677  
  5678  // Patch patches the properties of an existing Azure Cosmos DB database account.
  5679  // Parameters:
  5680  // resourceGroupName - name of an Azure resource group.
  5681  // accountName - cosmos DB database account name.
  5682  // updateParameters - the tags parameter to patch for the current database account.
  5683  func (client DatabaseAccountsClient) Patch(ctx context.Context, resourceGroupName string, accountName string, updateParameters DatabaseAccountPatchParameters) (result DatabaseAccountsPatchFuture, err error) {
  5684  	if tracing.IsEnabled() {
  5685  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Patch")
  5686  		defer func() {
  5687  			sc := -1
  5688  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5689  				sc = result.FutureAPI.Response().StatusCode
  5690  			}
  5691  			tracing.EndSpan(ctx, sc, err)
  5692  		}()
  5693  	}
  5694  	if err := validation.Validate([]validation.Validation{
  5695  		{TargetValue: resourceGroupName,
  5696  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5697  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5698  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5699  		{TargetValue: accountName,
  5700  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5701  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5702  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5703  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Patch", err.Error())
  5704  	}
  5705  
  5706  	req, err := client.PatchPreparer(ctx, resourceGroupName, accountName, updateParameters)
  5707  	if err != nil {
  5708  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Patch", nil, "Failure preparing request")
  5709  		return
  5710  	}
  5711  
  5712  	result, err = client.PatchSender(req)
  5713  	if err != nil {
  5714  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Patch", result.Response(), "Failure sending request")
  5715  		return
  5716  	}
  5717  
  5718  	return
  5719  }
  5720  
  5721  // PatchPreparer prepares the Patch request.
  5722  func (client DatabaseAccountsClient) PatchPreparer(ctx context.Context, resourceGroupName string, accountName string, updateParameters DatabaseAccountPatchParameters) (*http.Request, error) {
  5723  	pathParameters := map[string]interface{}{
  5724  		"accountName":       autorest.Encode("path", accountName),
  5725  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5726  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5727  	}
  5728  
  5729  	const APIVersion = "2015-04-08"
  5730  	queryParameters := map[string]interface{}{
  5731  		"api-version": APIVersion,
  5732  	}
  5733  
  5734  	preparer := autorest.CreatePreparer(
  5735  		autorest.AsContentType("application/json; charset=utf-8"),
  5736  		autorest.AsPatch(),
  5737  		autorest.WithBaseURL(client.BaseURI),
  5738  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
  5739  		autorest.WithJSON(updateParameters),
  5740  		autorest.WithQueryParameters(queryParameters))
  5741  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5742  }
  5743  
  5744  // PatchSender sends the Patch request. The method will close the
  5745  // http.Response Body if it receives an error.
  5746  func (client DatabaseAccountsClient) PatchSender(req *http.Request) (future DatabaseAccountsPatchFuture, err error) {
  5747  	var resp *http.Response
  5748  	future.FutureAPI = &azure.Future{}
  5749  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5750  	if err != nil {
  5751  		return
  5752  	}
  5753  	var azf azure.Future
  5754  	azf, err = azure.NewFutureFromResponse(resp)
  5755  	future.FutureAPI = &azf
  5756  	future.Result = future.result
  5757  	return
  5758  }
  5759  
  5760  // PatchResponder handles the response to the Patch request. The method always
  5761  // closes the http.Response Body.
  5762  func (client DatabaseAccountsClient) PatchResponder(resp *http.Response) (result DatabaseAccount, err error) {
  5763  	err = autorest.Respond(
  5764  		resp,
  5765  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  5766  		autorest.ByUnmarshallingJSON(&result),
  5767  		autorest.ByClosing())
  5768  	result.Response = autorest.Response{Response: resp}
  5769  	return
  5770  }
  5771  
  5772  // RegenerateKey regenerates an access key for the specified Azure Cosmos DB database account.
  5773  // Parameters:
  5774  // resourceGroupName - name of an Azure resource group.
  5775  // accountName - cosmos DB database account name.
  5776  // keyToRegenerate - the name of the key to regenerate.
  5777  func (client DatabaseAccountsClient) RegenerateKey(ctx context.Context, resourceGroupName string, accountName string, keyToRegenerate DatabaseAccountRegenerateKeyParameters) (result DatabaseAccountsRegenerateKeyFuture, err error) {
  5778  	if tracing.IsEnabled() {
  5779  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.RegenerateKey")
  5780  		defer func() {
  5781  			sc := -1
  5782  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5783  				sc = result.FutureAPI.Response().StatusCode
  5784  			}
  5785  			tracing.EndSpan(ctx, sc, err)
  5786  		}()
  5787  	}
  5788  	if err := validation.Validate([]validation.Validation{
  5789  		{TargetValue: resourceGroupName,
  5790  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5791  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5792  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5793  		{TargetValue: accountName,
  5794  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5795  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5796  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  5797  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "RegenerateKey", err.Error())
  5798  	}
  5799  
  5800  	req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, accountName, keyToRegenerate)
  5801  	if err != nil {
  5802  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "RegenerateKey", nil, "Failure preparing request")
  5803  		return
  5804  	}
  5805  
  5806  	result, err = client.RegenerateKeySender(req)
  5807  	if err != nil {
  5808  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "RegenerateKey", result.Response(), "Failure sending request")
  5809  		return
  5810  	}
  5811  
  5812  	return
  5813  }
  5814  
  5815  // RegenerateKeyPreparer prepares the RegenerateKey request.
  5816  func (client DatabaseAccountsClient) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, accountName string, keyToRegenerate DatabaseAccountRegenerateKeyParameters) (*http.Request, error) {
  5817  	pathParameters := map[string]interface{}{
  5818  		"accountName":       autorest.Encode("path", accountName),
  5819  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5820  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5821  	}
  5822  
  5823  	const APIVersion = "2015-04-08"
  5824  	queryParameters := map[string]interface{}{
  5825  		"api-version": APIVersion,
  5826  	}
  5827  
  5828  	preparer := autorest.CreatePreparer(
  5829  		autorest.AsContentType("application/json; charset=utf-8"),
  5830  		autorest.AsPost(),
  5831  		autorest.WithBaseURL(client.BaseURI),
  5832  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/regenerateKey", pathParameters),
  5833  		autorest.WithJSON(keyToRegenerate),
  5834  		autorest.WithQueryParameters(queryParameters))
  5835  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5836  }
  5837  
  5838  // RegenerateKeySender sends the RegenerateKey request. The method will close the
  5839  // http.Response Body if it receives an error.
  5840  func (client DatabaseAccountsClient) RegenerateKeySender(req *http.Request) (future DatabaseAccountsRegenerateKeyFuture, err error) {
  5841  	var resp *http.Response
  5842  	future.FutureAPI = &azure.Future{}
  5843  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5844  	if err != nil {
  5845  		return
  5846  	}
  5847  	var azf azure.Future
  5848  	azf, err = azure.NewFutureFromResponse(resp)
  5849  	future.FutureAPI = &azf
  5850  	future.Result = future.result
  5851  	return
  5852  }
  5853  
  5854  // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always
  5855  // closes the http.Response Body.
  5856  func (client DatabaseAccountsClient) RegenerateKeyResponder(resp *http.Response) (result autorest.Response, err error) {
  5857  	err = autorest.Respond(
  5858  		resp,
  5859  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  5860  		autorest.ByClosing())
  5861  	result.Response = resp
  5862  	return
  5863  }
  5864  
  5865  // UpdateCassandraKeyspaceThroughput update RUs per second of an Azure Cosmos DB Cassandra Keyspace
  5866  // Parameters:
  5867  // resourceGroupName - name of an Azure resource group.
  5868  // accountName - cosmos DB database account name.
  5869  // keyspaceName - cosmos DB keyspace name.
  5870  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Cassandra
  5871  // Keyspace.
  5872  func (client DatabaseAccountsClient) UpdateCassandraKeyspaceThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateCassandraKeyspaceThroughputFuture, err error) {
  5873  	if tracing.IsEnabled() {
  5874  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateCassandraKeyspaceThroughput")
  5875  		defer func() {
  5876  			sc := -1
  5877  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5878  				sc = result.FutureAPI.Response().StatusCode
  5879  			}
  5880  			tracing.EndSpan(ctx, sc, err)
  5881  		}()
  5882  	}
  5883  	if err := validation.Validate([]validation.Validation{
  5884  		{TargetValue: resourceGroupName,
  5885  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5886  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5887  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5888  		{TargetValue: accountName,
  5889  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5890  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5891  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  5892  		{TargetValue: updateThroughputParameters,
  5893  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  5894  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  5895  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  5896  				}}}}}); err != nil {
  5897  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateCassandraKeyspaceThroughput", err.Error())
  5898  	}
  5899  
  5900  	req, err := client.UpdateCassandraKeyspaceThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, updateThroughputParameters)
  5901  	if err != nil {
  5902  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateCassandraKeyspaceThroughput", nil, "Failure preparing request")
  5903  		return
  5904  	}
  5905  
  5906  	result, err = client.UpdateCassandraKeyspaceThroughputSender(req)
  5907  	if err != nil {
  5908  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateCassandraKeyspaceThroughput", result.Response(), "Failure sending request")
  5909  		return
  5910  	}
  5911  
  5912  	return
  5913  }
  5914  
  5915  // UpdateCassandraKeyspaceThroughputPreparer prepares the UpdateCassandraKeyspaceThroughput request.
  5916  func (client DatabaseAccountsClient) UpdateCassandraKeyspaceThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  5917  	pathParameters := map[string]interface{}{
  5918  		"accountName":       autorest.Encode("path", accountName),
  5919  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  5920  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  5921  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  5922  	}
  5923  
  5924  	const APIVersion = "2015-04-08"
  5925  	queryParameters := map[string]interface{}{
  5926  		"api-version": APIVersion,
  5927  	}
  5928  
  5929  	preparer := autorest.CreatePreparer(
  5930  		autorest.AsContentType("application/json; charset=utf-8"),
  5931  		autorest.AsPut(),
  5932  		autorest.WithBaseURL(client.BaseURI),
  5933  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/settings/throughput", pathParameters),
  5934  		autorest.WithJSON(updateThroughputParameters),
  5935  		autorest.WithQueryParameters(queryParameters))
  5936  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  5937  }
  5938  
  5939  // UpdateCassandraKeyspaceThroughputSender sends the UpdateCassandraKeyspaceThroughput request. The method will close the
  5940  // http.Response Body if it receives an error.
  5941  func (client DatabaseAccountsClient) UpdateCassandraKeyspaceThroughputSender(req *http.Request) (future DatabaseAccountsUpdateCassandraKeyspaceThroughputFuture, err error) {
  5942  	var resp *http.Response
  5943  	future.FutureAPI = &azure.Future{}
  5944  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  5945  	if err != nil {
  5946  		return
  5947  	}
  5948  	var azf azure.Future
  5949  	azf, err = azure.NewFutureFromResponse(resp)
  5950  	future.FutureAPI = &azf
  5951  	future.Result = future.result
  5952  	return
  5953  }
  5954  
  5955  // UpdateCassandraKeyspaceThroughputResponder handles the response to the UpdateCassandraKeyspaceThroughput request. The method always
  5956  // closes the http.Response Body.
  5957  func (client DatabaseAccountsClient) UpdateCassandraKeyspaceThroughputResponder(resp *http.Response) (result Throughput, err error) {
  5958  	err = autorest.Respond(
  5959  		resp,
  5960  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  5961  		autorest.ByUnmarshallingJSON(&result),
  5962  		autorest.ByClosing())
  5963  	result.Response = autorest.Response{Response: resp}
  5964  	return
  5965  }
  5966  
  5967  // UpdateCassandraTableThroughput update RUs per second of an Azure Cosmos DB Cassandra table
  5968  // Parameters:
  5969  // resourceGroupName - name of an Azure resource group.
  5970  // accountName - cosmos DB database account name.
  5971  // keyspaceName - cosmos DB keyspace name.
  5972  // tableName - cosmos DB table name.
  5973  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Cassandra
  5974  // table.
  5975  func (client DatabaseAccountsClient) UpdateCassandraTableThroughput(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateCassandraTableThroughputFuture, err error) {
  5976  	if tracing.IsEnabled() {
  5977  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateCassandraTableThroughput")
  5978  		defer func() {
  5979  			sc := -1
  5980  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  5981  				sc = result.FutureAPI.Response().StatusCode
  5982  			}
  5983  			tracing.EndSpan(ctx, sc, err)
  5984  		}()
  5985  	}
  5986  	if err := validation.Validate([]validation.Validation{
  5987  		{TargetValue: resourceGroupName,
  5988  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  5989  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  5990  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  5991  		{TargetValue: accountName,
  5992  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  5993  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  5994  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  5995  		{TargetValue: updateThroughputParameters,
  5996  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  5997  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  5998  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  5999  				}}}}}); err != nil {
  6000  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateCassandraTableThroughput", err.Error())
  6001  	}
  6002  
  6003  	req, err := client.UpdateCassandraTableThroughputPreparer(ctx, resourceGroupName, accountName, keyspaceName, tableName, updateThroughputParameters)
  6004  	if err != nil {
  6005  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateCassandraTableThroughput", nil, "Failure preparing request")
  6006  		return
  6007  	}
  6008  
  6009  	result, err = client.UpdateCassandraTableThroughputSender(req)
  6010  	if err != nil {
  6011  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateCassandraTableThroughput", result.Response(), "Failure sending request")
  6012  		return
  6013  	}
  6014  
  6015  	return
  6016  }
  6017  
  6018  // UpdateCassandraTableThroughputPreparer prepares the UpdateCassandraTableThroughput request.
  6019  func (client DatabaseAccountsClient) UpdateCassandraTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, keyspaceName string, tableName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6020  	pathParameters := map[string]interface{}{
  6021  		"accountName":       autorest.Encode("path", accountName),
  6022  		"keyspaceName":      autorest.Encode("path", keyspaceName),
  6023  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6024  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6025  		"tableName":         autorest.Encode("path", tableName),
  6026  	}
  6027  
  6028  	const APIVersion = "2015-04-08"
  6029  	queryParameters := map[string]interface{}{
  6030  		"api-version": APIVersion,
  6031  	}
  6032  
  6033  	preparer := autorest.CreatePreparer(
  6034  		autorest.AsContentType("application/json; charset=utf-8"),
  6035  		autorest.AsPut(),
  6036  		autorest.WithBaseURL(client.BaseURI),
  6037  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/cassandra/keyspaces/{keyspaceName}/tables/{tableName}/settings/throughput", pathParameters),
  6038  		autorest.WithJSON(updateThroughputParameters),
  6039  		autorest.WithQueryParameters(queryParameters))
  6040  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6041  }
  6042  
  6043  // UpdateCassandraTableThroughputSender sends the UpdateCassandraTableThroughput request. The method will close the
  6044  // http.Response Body if it receives an error.
  6045  func (client DatabaseAccountsClient) UpdateCassandraTableThroughputSender(req *http.Request) (future DatabaseAccountsUpdateCassandraTableThroughputFuture, err error) {
  6046  	var resp *http.Response
  6047  	future.FutureAPI = &azure.Future{}
  6048  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6049  	if err != nil {
  6050  		return
  6051  	}
  6052  	var azf azure.Future
  6053  	azf, err = azure.NewFutureFromResponse(resp)
  6054  	future.FutureAPI = &azf
  6055  	future.Result = future.result
  6056  	return
  6057  }
  6058  
  6059  // UpdateCassandraTableThroughputResponder handles the response to the UpdateCassandraTableThroughput request. The method always
  6060  // closes the http.Response Body.
  6061  func (client DatabaseAccountsClient) UpdateCassandraTableThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6062  	err = autorest.Respond(
  6063  		resp,
  6064  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6065  		autorest.ByUnmarshallingJSON(&result),
  6066  		autorest.ByClosing())
  6067  	result.Response = autorest.Response{Response: resp}
  6068  	return
  6069  }
  6070  
  6071  // UpdateGremlinDatabaseThroughput update RUs per second of an Azure Cosmos DB Gremlin database
  6072  // Parameters:
  6073  // resourceGroupName - name of an Azure resource group.
  6074  // accountName - cosmos DB database account name.
  6075  // databaseName - cosmos DB database name.
  6076  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Gremlin
  6077  // database.
  6078  func (client DatabaseAccountsClient) UpdateGremlinDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateGremlinDatabaseThroughputFuture, err error) {
  6079  	if tracing.IsEnabled() {
  6080  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateGremlinDatabaseThroughput")
  6081  		defer func() {
  6082  			sc := -1
  6083  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6084  				sc = result.FutureAPI.Response().StatusCode
  6085  			}
  6086  			tracing.EndSpan(ctx, sc, err)
  6087  		}()
  6088  	}
  6089  	if err := validation.Validate([]validation.Validation{
  6090  		{TargetValue: resourceGroupName,
  6091  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6092  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6093  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6094  		{TargetValue: accountName,
  6095  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6096  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6097  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6098  		{TargetValue: updateThroughputParameters,
  6099  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6100  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6101  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6102  				}}}}}); err != nil {
  6103  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateGremlinDatabaseThroughput", err.Error())
  6104  	}
  6105  
  6106  	req, err := client.UpdateGremlinDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, updateThroughputParameters)
  6107  	if err != nil {
  6108  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateGremlinDatabaseThroughput", nil, "Failure preparing request")
  6109  		return
  6110  	}
  6111  
  6112  	result, err = client.UpdateGremlinDatabaseThroughputSender(req)
  6113  	if err != nil {
  6114  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateGremlinDatabaseThroughput", result.Response(), "Failure sending request")
  6115  		return
  6116  	}
  6117  
  6118  	return
  6119  }
  6120  
  6121  // UpdateGremlinDatabaseThroughputPreparer prepares the UpdateGremlinDatabaseThroughput request.
  6122  func (client DatabaseAccountsClient) UpdateGremlinDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6123  	pathParameters := map[string]interface{}{
  6124  		"accountName":       autorest.Encode("path", accountName),
  6125  		"databaseName":      autorest.Encode("path", databaseName),
  6126  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6127  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6128  	}
  6129  
  6130  	const APIVersion = "2015-04-08"
  6131  	queryParameters := map[string]interface{}{
  6132  		"api-version": APIVersion,
  6133  	}
  6134  
  6135  	preparer := autorest.CreatePreparer(
  6136  		autorest.AsContentType("application/json; charset=utf-8"),
  6137  		autorest.AsPut(),
  6138  		autorest.WithBaseURL(client.BaseURI),
  6139  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/settings/throughput", pathParameters),
  6140  		autorest.WithJSON(updateThroughputParameters),
  6141  		autorest.WithQueryParameters(queryParameters))
  6142  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6143  }
  6144  
  6145  // UpdateGremlinDatabaseThroughputSender sends the UpdateGremlinDatabaseThroughput request. The method will close the
  6146  // http.Response Body if it receives an error.
  6147  func (client DatabaseAccountsClient) UpdateGremlinDatabaseThroughputSender(req *http.Request) (future DatabaseAccountsUpdateGremlinDatabaseThroughputFuture, err error) {
  6148  	var resp *http.Response
  6149  	future.FutureAPI = &azure.Future{}
  6150  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6151  	if err != nil {
  6152  		return
  6153  	}
  6154  	var azf azure.Future
  6155  	azf, err = azure.NewFutureFromResponse(resp)
  6156  	future.FutureAPI = &azf
  6157  	future.Result = future.result
  6158  	return
  6159  }
  6160  
  6161  // UpdateGremlinDatabaseThroughputResponder handles the response to the UpdateGremlinDatabaseThroughput request. The method always
  6162  // closes the http.Response Body.
  6163  func (client DatabaseAccountsClient) UpdateGremlinDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6164  	err = autorest.Respond(
  6165  		resp,
  6166  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6167  		autorest.ByUnmarshallingJSON(&result),
  6168  		autorest.ByClosing())
  6169  	result.Response = autorest.Response{Response: resp}
  6170  	return
  6171  }
  6172  
  6173  // UpdateGremlinGraphThroughput update RUs per second of an Azure Cosmos DB Gremlin graph
  6174  // Parameters:
  6175  // resourceGroupName - name of an Azure resource group.
  6176  // accountName - cosmos DB database account name.
  6177  // databaseName - cosmos DB database name.
  6178  // graphName - cosmos DB graph name.
  6179  // updateThroughputParameters - the RUs per second of the parameters to provide for the current Gremlin graph.
  6180  func (client DatabaseAccountsClient) UpdateGremlinGraphThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateGremlinGraphThroughputFuture, err error) {
  6181  	if tracing.IsEnabled() {
  6182  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateGremlinGraphThroughput")
  6183  		defer func() {
  6184  			sc := -1
  6185  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6186  				sc = result.FutureAPI.Response().StatusCode
  6187  			}
  6188  			tracing.EndSpan(ctx, sc, err)
  6189  		}()
  6190  	}
  6191  	if err := validation.Validate([]validation.Validation{
  6192  		{TargetValue: resourceGroupName,
  6193  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6194  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6195  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6196  		{TargetValue: accountName,
  6197  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6198  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6199  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6200  		{TargetValue: updateThroughputParameters,
  6201  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6202  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6203  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6204  				}}}}}); err != nil {
  6205  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateGremlinGraphThroughput", err.Error())
  6206  	}
  6207  
  6208  	req, err := client.UpdateGremlinGraphThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, graphName, updateThroughputParameters)
  6209  	if err != nil {
  6210  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateGremlinGraphThroughput", nil, "Failure preparing request")
  6211  		return
  6212  	}
  6213  
  6214  	result, err = client.UpdateGremlinGraphThroughputSender(req)
  6215  	if err != nil {
  6216  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateGremlinGraphThroughput", result.Response(), "Failure sending request")
  6217  		return
  6218  	}
  6219  
  6220  	return
  6221  }
  6222  
  6223  // UpdateGremlinGraphThroughputPreparer prepares the UpdateGremlinGraphThroughput request.
  6224  func (client DatabaseAccountsClient) UpdateGremlinGraphThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, graphName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6225  	pathParameters := map[string]interface{}{
  6226  		"accountName":       autorest.Encode("path", accountName),
  6227  		"databaseName":      autorest.Encode("path", databaseName),
  6228  		"graphName":         autorest.Encode("path", graphName),
  6229  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6230  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6231  	}
  6232  
  6233  	const APIVersion = "2015-04-08"
  6234  	queryParameters := map[string]interface{}{
  6235  		"api-version": APIVersion,
  6236  	}
  6237  
  6238  	preparer := autorest.CreatePreparer(
  6239  		autorest.AsContentType("application/json; charset=utf-8"),
  6240  		autorest.AsPut(),
  6241  		autorest.WithBaseURL(client.BaseURI),
  6242  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/gremlin/databases/{databaseName}/graphs/{graphName}/settings/throughput", pathParameters),
  6243  		autorest.WithJSON(updateThroughputParameters),
  6244  		autorest.WithQueryParameters(queryParameters))
  6245  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6246  }
  6247  
  6248  // UpdateGremlinGraphThroughputSender sends the UpdateGremlinGraphThroughput request. The method will close the
  6249  // http.Response Body if it receives an error.
  6250  func (client DatabaseAccountsClient) UpdateGremlinGraphThroughputSender(req *http.Request) (future DatabaseAccountsUpdateGremlinGraphThroughputFuture, err error) {
  6251  	var resp *http.Response
  6252  	future.FutureAPI = &azure.Future{}
  6253  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6254  	if err != nil {
  6255  		return
  6256  	}
  6257  	var azf azure.Future
  6258  	azf, err = azure.NewFutureFromResponse(resp)
  6259  	future.FutureAPI = &azf
  6260  	future.Result = future.result
  6261  	return
  6262  }
  6263  
  6264  // UpdateGremlinGraphThroughputResponder handles the response to the UpdateGremlinGraphThroughput request. The method always
  6265  // closes the http.Response Body.
  6266  func (client DatabaseAccountsClient) UpdateGremlinGraphThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6267  	err = autorest.Respond(
  6268  		resp,
  6269  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6270  		autorest.ByUnmarshallingJSON(&result),
  6271  		autorest.ByClosing())
  6272  	result.Response = autorest.Response{Response: resp}
  6273  	return
  6274  }
  6275  
  6276  // UpdateMongoDBCollectionThroughput update the RUs per second of an Azure Cosmos DB MongoDB collection
  6277  // Parameters:
  6278  // resourceGroupName - name of an Azure resource group.
  6279  // accountName - cosmos DB database account name.
  6280  // databaseName - cosmos DB database name.
  6281  // collectionName - cosmos DB collection name.
  6282  // updateThroughputParameters - the RUs per second of the parameters to provide for the current MongoDB
  6283  // collection.
  6284  func (client DatabaseAccountsClient) UpdateMongoDBCollectionThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateMongoDBCollectionThroughputFuture, err error) {
  6285  	if tracing.IsEnabled() {
  6286  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateMongoDBCollectionThroughput")
  6287  		defer func() {
  6288  			sc := -1
  6289  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6290  				sc = result.FutureAPI.Response().StatusCode
  6291  			}
  6292  			tracing.EndSpan(ctx, sc, err)
  6293  		}()
  6294  	}
  6295  	if err := validation.Validate([]validation.Validation{
  6296  		{TargetValue: resourceGroupName,
  6297  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6298  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6299  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6300  		{TargetValue: accountName,
  6301  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6302  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6303  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6304  		{TargetValue: updateThroughputParameters,
  6305  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6306  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6307  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6308  				}}}}}); err != nil {
  6309  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateMongoDBCollectionThroughput", err.Error())
  6310  	}
  6311  
  6312  	req, err := client.UpdateMongoDBCollectionThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, collectionName, updateThroughputParameters)
  6313  	if err != nil {
  6314  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateMongoDBCollectionThroughput", nil, "Failure preparing request")
  6315  		return
  6316  	}
  6317  
  6318  	result, err = client.UpdateMongoDBCollectionThroughputSender(req)
  6319  	if err != nil {
  6320  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateMongoDBCollectionThroughput", result.Response(), "Failure sending request")
  6321  		return
  6322  	}
  6323  
  6324  	return
  6325  }
  6326  
  6327  // UpdateMongoDBCollectionThroughputPreparer prepares the UpdateMongoDBCollectionThroughput request.
  6328  func (client DatabaseAccountsClient) UpdateMongoDBCollectionThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, collectionName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6329  	pathParameters := map[string]interface{}{
  6330  		"accountName":       autorest.Encode("path", accountName),
  6331  		"collectionName":    autorest.Encode("path", collectionName),
  6332  		"databaseName":      autorest.Encode("path", databaseName),
  6333  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6334  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6335  	}
  6336  
  6337  	const APIVersion = "2015-04-08"
  6338  	queryParameters := map[string]interface{}{
  6339  		"api-version": APIVersion,
  6340  	}
  6341  
  6342  	preparer := autorest.CreatePreparer(
  6343  		autorest.AsContentType("application/json; charset=utf-8"),
  6344  		autorest.AsPut(),
  6345  		autorest.WithBaseURL(client.BaseURI),
  6346  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/collections/{collectionName}/settings/throughput", pathParameters),
  6347  		autorest.WithJSON(updateThroughputParameters),
  6348  		autorest.WithQueryParameters(queryParameters))
  6349  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6350  }
  6351  
  6352  // UpdateMongoDBCollectionThroughputSender sends the UpdateMongoDBCollectionThroughput request. The method will close the
  6353  // http.Response Body if it receives an error.
  6354  func (client DatabaseAccountsClient) UpdateMongoDBCollectionThroughputSender(req *http.Request) (future DatabaseAccountsUpdateMongoDBCollectionThroughputFuture, err error) {
  6355  	var resp *http.Response
  6356  	future.FutureAPI = &azure.Future{}
  6357  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6358  	if err != nil {
  6359  		return
  6360  	}
  6361  	var azf azure.Future
  6362  	azf, err = azure.NewFutureFromResponse(resp)
  6363  	future.FutureAPI = &azf
  6364  	future.Result = future.result
  6365  	return
  6366  }
  6367  
  6368  // UpdateMongoDBCollectionThroughputResponder handles the response to the UpdateMongoDBCollectionThroughput request. The method always
  6369  // closes the http.Response Body.
  6370  func (client DatabaseAccountsClient) UpdateMongoDBCollectionThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6371  	err = autorest.Respond(
  6372  		resp,
  6373  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6374  		autorest.ByUnmarshallingJSON(&result),
  6375  		autorest.ByClosing())
  6376  	result.Response = autorest.Response{Response: resp}
  6377  	return
  6378  }
  6379  
  6380  // UpdateMongoDBDatabaseThroughput update RUs per second of the an Azure Cosmos DB MongoDB database
  6381  // Parameters:
  6382  // resourceGroupName - name of an Azure resource group.
  6383  // accountName - cosmos DB database account name.
  6384  // databaseName - cosmos DB database name.
  6385  // updateThroughputParameters - the RUs per second of the parameters to provide for the current MongoDB
  6386  // database.
  6387  func (client DatabaseAccountsClient) UpdateMongoDBDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateMongoDBDatabaseThroughputFuture, err error) {
  6388  	if tracing.IsEnabled() {
  6389  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateMongoDBDatabaseThroughput")
  6390  		defer func() {
  6391  			sc := -1
  6392  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6393  				sc = result.FutureAPI.Response().StatusCode
  6394  			}
  6395  			tracing.EndSpan(ctx, sc, err)
  6396  		}()
  6397  	}
  6398  	if err := validation.Validate([]validation.Validation{
  6399  		{TargetValue: resourceGroupName,
  6400  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6401  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6402  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6403  		{TargetValue: accountName,
  6404  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6405  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6406  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6407  		{TargetValue: updateThroughputParameters,
  6408  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6409  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6410  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6411  				}}}}}); err != nil {
  6412  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateMongoDBDatabaseThroughput", err.Error())
  6413  	}
  6414  
  6415  	req, err := client.UpdateMongoDBDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, updateThroughputParameters)
  6416  	if err != nil {
  6417  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateMongoDBDatabaseThroughput", nil, "Failure preparing request")
  6418  		return
  6419  	}
  6420  
  6421  	result, err = client.UpdateMongoDBDatabaseThroughputSender(req)
  6422  	if err != nil {
  6423  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateMongoDBDatabaseThroughput", result.Response(), "Failure sending request")
  6424  		return
  6425  	}
  6426  
  6427  	return
  6428  }
  6429  
  6430  // UpdateMongoDBDatabaseThroughputPreparer prepares the UpdateMongoDBDatabaseThroughput request.
  6431  func (client DatabaseAccountsClient) UpdateMongoDBDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6432  	pathParameters := map[string]interface{}{
  6433  		"accountName":       autorest.Encode("path", accountName),
  6434  		"databaseName":      autorest.Encode("path", databaseName),
  6435  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6436  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6437  	}
  6438  
  6439  	const APIVersion = "2015-04-08"
  6440  	queryParameters := map[string]interface{}{
  6441  		"api-version": APIVersion,
  6442  	}
  6443  
  6444  	preparer := autorest.CreatePreparer(
  6445  		autorest.AsContentType("application/json; charset=utf-8"),
  6446  		autorest.AsPut(),
  6447  		autorest.WithBaseURL(client.BaseURI),
  6448  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/mongodb/databases/{databaseName}/settings/throughput", pathParameters),
  6449  		autorest.WithJSON(updateThroughputParameters),
  6450  		autorest.WithQueryParameters(queryParameters))
  6451  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6452  }
  6453  
  6454  // UpdateMongoDBDatabaseThroughputSender sends the UpdateMongoDBDatabaseThroughput request. The method will close the
  6455  // http.Response Body if it receives an error.
  6456  func (client DatabaseAccountsClient) UpdateMongoDBDatabaseThroughputSender(req *http.Request) (future DatabaseAccountsUpdateMongoDBDatabaseThroughputFuture, err error) {
  6457  	var resp *http.Response
  6458  	future.FutureAPI = &azure.Future{}
  6459  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6460  	if err != nil {
  6461  		return
  6462  	}
  6463  	var azf azure.Future
  6464  	azf, err = azure.NewFutureFromResponse(resp)
  6465  	future.FutureAPI = &azf
  6466  	future.Result = future.result
  6467  	return
  6468  }
  6469  
  6470  // UpdateMongoDBDatabaseThroughputResponder handles the response to the UpdateMongoDBDatabaseThroughput request. The method always
  6471  // closes the http.Response Body.
  6472  func (client DatabaseAccountsClient) UpdateMongoDBDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6473  	err = autorest.Respond(
  6474  		resp,
  6475  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6476  		autorest.ByUnmarshallingJSON(&result),
  6477  		autorest.ByClosing())
  6478  	result.Response = autorest.Response{Response: resp}
  6479  	return
  6480  }
  6481  
  6482  // UpdateSQLContainerThroughput update RUs per second of an Azure Cosmos DB SQL container
  6483  // Parameters:
  6484  // resourceGroupName - name of an Azure resource group.
  6485  // accountName - cosmos DB database account name.
  6486  // databaseName - cosmos DB database name.
  6487  // containerName - cosmos DB container name.
  6488  // updateThroughputParameters - the parameters to provide for the RUs per second of the current SQL container.
  6489  func (client DatabaseAccountsClient) UpdateSQLContainerThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateSQLContainerThroughputFuture, err error) {
  6490  	if tracing.IsEnabled() {
  6491  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateSQLContainerThroughput")
  6492  		defer func() {
  6493  			sc := -1
  6494  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6495  				sc = result.FutureAPI.Response().StatusCode
  6496  			}
  6497  			tracing.EndSpan(ctx, sc, err)
  6498  		}()
  6499  	}
  6500  	if err := validation.Validate([]validation.Validation{
  6501  		{TargetValue: resourceGroupName,
  6502  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6503  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6504  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6505  		{TargetValue: accountName,
  6506  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6507  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6508  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6509  		{TargetValue: updateThroughputParameters,
  6510  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6511  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6512  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6513  				}}}}}); err != nil {
  6514  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateSQLContainerThroughput", err.Error())
  6515  	}
  6516  
  6517  	req, err := client.UpdateSQLContainerThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, containerName, updateThroughputParameters)
  6518  	if err != nil {
  6519  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateSQLContainerThroughput", nil, "Failure preparing request")
  6520  		return
  6521  	}
  6522  
  6523  	result, err = client.UpdateSQLContainerThroughputSender(req)
  6524  	if err != nil {
  6525  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateSQLContainerThroughput", result.Response(), "Failure sending request")
  6526  		return
  6527  	}
  6528  
  6529  	return
  6530  }
  6531  
  6532  // UpdateSQLContainerThroughputPreparer prepares the UpdateSQLContainerThroughput request.
  6533  func (client DatabaseAccountsClient) UpdateSQLContainerThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, containerName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6534  	pathParameters := map[string]interface{}{
  6535  		"accountName":       autorest.Encode("path", accountName),
  6536  		"containerName":     autorest.Encode("path", containerName),
  6537  		"databaseName":      autorest.Encode("path", databaseName),
  6538  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6539  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6540  	}
  6541  
  6542  	const APIVersion = "2015-04-08"
  6543  	queryParameters := map[string]interface{}{
  6544  		"api-version": APIVersion,
  6545  	}
  6546  
  6547  	preparer := autorest.CreatePreparer(
  6548  		autorest.AsContentType("application/json; charset=utf-8"),
  6549  		autorest.AsPut(),
  6550  		autorest.WithBaseURL(client.BaseURI),
  6551  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/containers/{containerName}/settings/throughput", pathParameters),
  6552  		autorest.WithJSON(updateThroughputParameters),
  6553  		autorest.WithQueryParameters(queryParameters))
  6554  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6555  }
  6556  
  6557  // UpdateSQLContainerThroughputSender sends the UpdateSQLContainerThroughput request. The method will close the
  6558  // http.Response Body if it receives an error.
  6559  func (client DatabaseAccountsClient) UpdateSQLContainerThroughputSender(req *http.Request) (future DatabaseAccountsUpdateSQLContainerThroughputFuture, err error) {
  6560  	var resp *http.Response
  6561  	future.FutureAPI = &azure.Future{}
  6562  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6563  	if err != nil {
  6564  		return
  6565  	}
  6566  	var azf azure.Future
  6567  	azf, err = azure.NewFutureFromResponse(resp)
  6568  	future.FutureAPI = &azf
  6569  	future.Result = future.result
  6570  	return
  6571  }
  6572  
  6573  // UpdateSQLContainerThroughputResponder handles the response to the UpdateSQLContainerThroughput request. The method always
  6574  // closes the http.Response Body.
  6575  func (client DatabaseAccountsClient) UpdateSQLContainerThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6576  	err = autorest.Respond(
  6577  		resp,
  6578  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6579  		autorest.ByUnmarshallingJSON(&result),
  6580  		autorest.ByClosing())
  6581  	result.Response = autorest.Response{Response: resp}
  6582  	return
  6583  }
  6584  
  6585  // UpdateSQLDatabaseThroughput update RUs per second of an Azure Cosmos DB SQL database
  6586  // Parameters:
  6587  // resourceGroupName - name of an Azure resource group.
  6588  // accountName - cosmos DB database account name.
  6589  // databaseName - cosmos DB database name.
  6590  // updateThroughputParameters - the parameters to provide for the RUs per second of the current SQL database.
  6591  func (client DatabaseAccountsClient) UpdateSQLDatabaseThroughput(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateSQLDatabaseThroughputFuture, err error) {
  6592  	if tracing.IsEnabled() {
  6593  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateSQLDatabaseThroughput")
  6594  		defer func() {
  6595  			sc := -1
  6596  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6597  				sc = result.FutureAPI.Response().StatusCode
  6598  			}
  6599  			tracing.EndSpan(ctx, sc, err)
  6600  		}()
  6601  	}
  6602  	if err := validation.Validate([]validation.Validation{
  6603  		{TargetValue: resourceGroupName,
  6604  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6605  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6606  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6607  		{TargetValue: accountName,
  6608  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6609  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6610  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6611  		{TargetValue: updateThroughputParameters,
  6612  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6613  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6614  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6615  				}}}}}); err != nil {
  6616  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateSQLDatabaseThroughput", err.Error())
  6617  	}
  6618  
  6619  	req, err := client.UpdateSQLDatabaseThroughputPreparer(ctx, resourceGroupName, accountName, databaseName, updateThroughputParameters)
  6620  	if err != nil {
  6621  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateSQLDatabaseThroughput", nil, "Failure preparing request")
  6622  		return
  6623  	}
  6624  
  6625  	result, err = client.UpdateSQLDatabaseThroughputSender(req)
  6626  	if err != nil {
  6627  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateSQLDatabaseThroughput", result.Response(), "Failure sending request")
  6628  		return
  6629  	}
  6630  
  6631  	return
  6632  }
  6633  
  6634  // UpdateSQLDatabaseThroughputPreparer prepares the UpdateSQLDatabaseThroughput request.
  6635  func (client DatabaseAccountsClient) UpdateSQLDatabaseThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, databaseName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6636  	pathParameters := map[string]interface{}{
  6637  		"accountName":       autorest.Encode("path", accountName),
  6638  		"databaseName":      autorest.Encode("path", databaseName),
  6639  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6640  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6641  	}
  6642  
  6643  	const APIVersion = "2015-04-08"
  6644  	queryParameters := map[string]interface{}{
  6645  		"api-version": APIVersion,
  6646  	}
  6647  
  6648  	preparer := autorest.CreatePreparer(
  6649  		autorest.AsContentType("application/json; charset=utf-8"),
  6650  		autorest.AsPut(),
  6651  		autorest.WithBaseURL(client.BaseURI),
  6652  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/sql/databases/{databaseName}/settings/throughput", pathParameters),
  6653  		autorest.WithJSON(updateThroughputParameters),
  6654  		autorest.WithQueryParameters(queryParameters))
  6655  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6656  }
  6657  
  6658  // UpdateSQLDatabaseThroughputSender sends the UpdateSQLDatabaseThroughput request. The method will close the
  6659  // http.Response Body if it receives an error.
  6660  func (client DatabaseAccountsClient) UpdateSQLDatabaseThroughputSender(req *http.Request) (future DatabaseAccountsUpdateSQLDatabaseThroughputFuture, err error) {
  6661  	var resp *http.Response
  6662  	future.FutureAPI = &azure.Future{}
  6663  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6664  	if err != nil {
  6665  		return
  6666  	}
  6667  	var azf azure.Future
  6668  	azf, err = azure.NewFutureFromResponse(resp)
  6669  	future.FutureAPI = &azf
  6670  	future.Result = future.result
  6671  	return
  6672  }
  6673  
  6674  // UpdateSQLDatabaseThroughputResponder handles the response to the UpdateSQLDatabaseThroughput request. The method always
  6675  // closes the http.Response Body.
  6676  func (client DatabaseAccountsClient) UpdateSQLDatabaseThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6677  	err = autorest.Respond(
  6678  		resp,
  6679  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6680  		autorest.ByUnmarshallingJSON(&result),
  6681  		autorest.ByClosing())
  6682  	result.Response = autorest.Response{Response: resp}
  6683  	return
  6684  }
  6685  
  6686  // UpdateTableThroughput update RUs per second of an Azure Cosmos DB Table
  6687  // Parameters:
  6688  // resourceGroupName - name of an Azure resource group.
  6689  // accountName - cosmos DB database account name.
  6690  // tableName - cosmos DB table name.
  6691  // updateThroughputParameters - the parameters to provide for the RUs per second of the current Table.
  6692  func (client DatabaseAccountsClient) UpdateTableThroughput(ctx context.Context, resourceGroupName string, accountName string, tableName string, updateThroughputParameters ThroughputUpdateParameters) (result DatabaseAccountsUpdateTableThroughputFuture, err error) {
  6693  	if tracing.IsEnabled() {
  6694  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.UpdateTableThroughput")
  6695  		defer func() {
  6696  			sc := -1
  6697  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  6698  				sc = result.FutureAPI.Response().StatusCode
  6699  			}
  6700  			tracing.EndSpan(ctx, sc, err)
  6701  		}()
  6702  	}
  6703  	if err := validation.Validate([]validation.Validation{
  6704  		{TargetValue: resourceGroupName,
  6705  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  6706  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  6707  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  6708  		{TargetValue: accountName,
  6709  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  6710  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  6711  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  6712  		{TargetValue: updateThroughputParameters,
  6713  			Constraints: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties", Name: validation.Null, Rule: true,
  6714  				Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource", Name: validation.Null, Rule: true,
  6715  					Chain: []validation.Constraint{{Target: "updateThroughputParameters.ThroughputUpdateProperties.Resource.Throughput", Name: validation.Null, Rule: true, Chain: nil}}},
  6716  				}}}}}); err != nil {
  6717  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "UpdateTableThroughput", err.Error())
  6718  	}
  6719  
  6720  	req, err := client.UpdateTableThroughputPreparer(ctx, resourceGroupName, accountName, tableName, updateThroughputParameters)
  6721  	if err != nil {
  6722  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateTableThroughput", nil, "Failure preparing request")
  6723  		return
  6724  	}
  6725  
  6726  	result, err = client.UpdateTableThroughputSender(req)
  6727  	if err != nil {
  6728  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "UpdateTableThroughput", result.Response(), "Failure sending request")
  6729  		return
  6730  	}
  6731  
  6732  	return
  6733  }
  6734  
  6735  // UpdateTableThroughputPreparer prepares the UpdateTableThroughput request.
  6736  func (client DatabaseAccountsClient) UpdateTableThroughputPreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string, updateThroughputParameters ThroughputUpdateParameters) (*http.Request, error) {
  6737  	pathParameters := map[string]interface{}{
  6738  		"accountName":       autorest.Encode("path", accountName),
  6739  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  6740  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  6741  		"tableName":         autorest.Encode("path", tableName),
  6742  	}
  6743  
  6744  	const APIVersion = "2015-04-08"
  6745  	queryParameters := map[string]interface{}{
  6746  		"api-version": APIVersion,
  6747  	}
  6748  
  6749  	preparer := autorest.CreatePreparer(
  6750  		autorest.AsContentType("application/json; charset=utf-8"),
  6751  		autorest.AsPut(),
  6752  		autorest.WithBaseURL(client.BaseURI),
  6753  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/apis/table/tables/{tableName}/settings/throughput", pathParameters),
  6754  		autorest.WithJSON(updateThroughputParameters),
  6755  		autorest.WithQueryParameters(queryParameters))
  6756  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  6757  }
  6758  
  6759  // UpdateTableThroughputSender sends the UpdateTableThroughput request. The method will close the
  6760  // http.Response Body if it receives an error.
  6761  func (client DatabaseAccountsClient) UpdateTableThroughputSender(req *http.Request) (future DatabaseAccountsUpdateTableThroughputFuture, err error) {
  6762  	var resp *http.Response
  6763  	future.FutureAPI = &azure.Future{}
  6764  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  6765  	if err != nil {
  6766  		return
  6767  	}
  6768  	var azf azure.Future
  6769  	azf, err = azure.NewFutureFromResponse(resp)
  6770  	future.FutureAPI = &azf
  6771  	future.Result = future.result
  6772  	return
  6773  }
  6774  
  6775  // UpdateTableThroughputResponder handles the response to the UpdateTableThroughput request. The method always
  6776  // closes the http.Response Body.
  6777  func (client DatabaseAccountsClient) UpdateTableThroughputResponder(resp *http.Response) (result Throughput, err error) {
  6778  	err = autorest.Respond(
  6779  		resp,
  6780  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  6781  		autorest.ByUnmarshallingJSON(&result),
  6782  		autorest.ByClosing())
  6783  	result.Response = autorest.Response{Response: resp}
  6784  	return
  6785  }
  6786  

View as plain text