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

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/cosmos-db/mgmt/2021-04-01-preview/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 client for the DatabaseAccounts methods of the Documentdb service.
    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 = "2021-04-01-preview"
    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. The "Update" method is preferred when
   117  // performing updates on an account.
   118  // Parameters:
   119  // resourceGroupName - the name of the resource group. The name is case insensitive.
   120  // accountName - cosmos DB database account name.
   121  // createUpdateParameters - the parameters to provide for the current database account.
   122  func (client DatabaseAccountsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, createUpdateParameters DatabaseAccountCreateUpdateParameters) (result DatabaseAccountsCreateOrUpdateFuture, err error) {
   123  	if tracing.IsEnabled() {
   124  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.CreateOrUpdate")
   125  		defer func() {
   126  			sc := -1
   127  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   128  				sc = result.FutureAPI.Response().StatusCode
   129  			}
   130  			tracing.EndSpan(ctx, sc, err)
   131  		}()
   132  	}
   133  	if err := validation.Validate([]validation.Validation{
   134  		{TargetValue: client.SubscriptionID,
   135  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   136  		{TargetValue: resourceGroupName,
   137  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   138  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   139  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   140  		{TargetValue: accountName,
   141  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   142  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   143  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   144  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "CreateOrUpdate", err.Error())
   145  	}
   146  
   147  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, createUpdateParameters)
   148  	if err != nil {
   149  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateOrUpdate", nil, "Failure preparing request")
   150  		return
   151  	}
   152  
   153  	result, err = client.CreateOrUpdateSender(req)
   154  	if err != nil {
   155  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   156  		return
   157  	}
   158  
   159  	return
   160  }
   161  
   162  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   163  func (client DatabaseAccountsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, createUpdateParameters DatabaseAccountCreateUpdateParameters) (*http.Request, error) {
   164  	pathParameters := map[string]interface{}{
   165  		"accountName":       autorest.Encode("path", accountName),
   166  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   167  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   168  	}
   169  
   170  	const APIVersion = "2021-04-01-preview"
   171  	queryParameters := map[string]interface{}{
   172  		"api-version": APIVersion,
   173  	}
   174  
   175  	preparer := autorest.CreatePreparer(
   176  		autorest.AsContentType("application/json; charset=utf-8"),
   177  		autorest.AsPut(),
   178  		autorest.WithBaseURL(client.BaseURI),
   179  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
   180  		autorest.WithJSON(createUpdateParameters),
   181  		autorest.WithQueryParameters(queryParameters))
   182  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   183  }
   184  
   185  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   186  // http.Response Body if it receives an error.
   187  func (client DatabaseAccountsClient) CreateOrUpdateSender(req *http.Request) (future DatabaseAccountsCreateOrUpdateFuture, err error) {
   188  	var resp *http.Response
   189  	future.FutureAPI = &azure.Future{}
   190  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   191  	if err != nil {
   192  		return
   193  	}
   194  	var azf azure.Future
   195  	azf, err = azure.NewFutureFromResponse(resp)
   196  	future.FutureAPI = &azf
   197  	future.Result = future.result
   198  	return
   199  }
   200  
   201  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   202  // closes the http.Response Body.
   203  func (client DatabaseAccountsClient) CreateOrUpdateResponder(resp *http.Response) (result DatabaseAccountGetResults, err error) {
   204  	err = autorest.Respond(
   205  		resp,
   206  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   207  		autorest.ByUnmarshallingJSON(&result),
   208  		autorest.ByClosing())
   209  	result.Response = autorest.Response{Response: resp}
   210  	return
   211  }
   212  
   213  // Delete deletes an existing Azure Cosmos DB database account.
   214  // Parameters:
   215  // resourceGroupName - the name of the resource group. The name is case insensitive.
   216  // accountName - cosmos DB database account name.
   217  func (client DatabaseAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountsDeleteFuture, err error) {
   218  	if tracing.IsEnabled() {
   219  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Delete")
   220  		defer func() {
   221  			sc := -1
   222  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   223  				sc = result.FutureAPI.Response().StatusCode
   224  			}
   225  			tracing.EndSpan(ctx, sc, err)
   226  		}()
   227  	}
   228  	if err := validation.Validate([]validation.Validation{
   229  		{TargetValue: client.SubscriptionID,
   230  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   231  		{TargetValue: resourceGroupName,
   232  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   233  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   234  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   235  		{TargetValue: accountName,
   236  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   237  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   238  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   239  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Delete", err.Error())
   240  	}
   241  
   242  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
   243  	if err != nil {
   244  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Delete", nil, "Failure preparing request")
   245  		return
   246  	}
   247  
   248  	result, err = client.DeleteSender(req)
   249  	if err != nil {
   250  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Delete", result.Response(), "Failure sending request")
   251  		return
   252  	}
   253  
   254  	return
   255  }
   256  
   257  // DeletePreparer prepares the Delete request.
   258  func (client DatabaseAccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   259  	pathParameters := map[string]interface{}{
   260  		"accountName":       autorest.Encode("path", accountName),
   261  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   262  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   263  	}
   264  
   265  	const APIVersion = "2021-04-01-preview"
   266  	queryParameters := map[string]interface{}{
   267  		"api-version": APIVersion,
   268  	}
   269  
   270  	preparer := autorest.CreatePreparer(
   271  		autorest.AsDelete(),
   272  		autorest.WithBaseURL(client.BaseURI),
   273  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
   274  		autorest.WithQueryParameters(queryParameters))
   275  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   276  }
   277  
   278  // DeleteSender sends the Delete request. The method will close the
   279  // http.Response Body if it receives an error.
   280  func (client DatabaseAccountsClient) DeleteSender(req *http.Request) (future DatabaseAccountsDeleteFuture, err error) {
   281  	var resp *http.Response
   282  	future.FutureAPI = &azure.Future{}
   283  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   284  	if err != nil {
   285  		return
   286  	}
   287  	var azf azure.Future
   288  	azf, err = azure.NewFutureFromResponse(resp)
   289  	future.FutureAPI = &azf
   290  	future.Result = future.result
   291  	return
   292  }
   293  
   294  // DeleteResponder handles the response to the Delete request. The method always
   295  // closes the http.Response Body.
   296  func (client DatabaseAccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   297  	err = autorest.Respond(
   298  		resp,
   299  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   300  		autorest.ByClosing())
   301  	result.Response = resp
   302  	return
   303  }
   304  
   305  // FailoverPriorityChange changes the failover priority for the Azure Cosmos DB database account. A failover priority
   306  // of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover
   307  // priority values must be unique for each of the regions in which the database account exists.
   308  // Parameters:
   309  // resourceGroupName - the name of the resource group. The name is case insensitive.
   310  // accountName - cosmos DB database account name.
   311  // failoverParameters - the new failover policies for the database account.
   312  func (client DatabaseAccountsClient) FailoverPriorityChange(ctx context.Context, resourceGroupName string, accountName string, failoverParameters FailoverPolicies) (result DatabaseAccountsFailoverPriorityChangeFuture, err error) {
   313  	if tracing.IsEnabled() {
   314  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.FailoverPriorityChange")
   315  		defer func() {
   316  			sc := -1
   317  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   318  				sc = result.FutureAPI.Response().StatusCode
   319  			}
   320  			tracing.EndSpan(ctx, sc, err)
   321  		}()
   322  	}
   323  	if err := validation.Validate([]validation.Validation{
   324  		{TargetValue: client.SubscriptionID,
   325  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   326  		{TargetValue: resourceGroupName,
   327  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   328  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   329  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   330  		{TargetValue: accountName,
   331  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   332  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   333  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
   334  		{TargetValue: failoverParameters,
   335  			Constraints: []validation.Constraint{{Target: "failoverParameters.FailoverPolicies", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   336  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "FailoverPriorityChange", err.Error())
   337  	}
   338  
   339  	req, err := client.FailoverPriorityChangePreparer(ctx, resourceGroupName, accountName, failoverParameters)
   340  	if err != nil {
   341  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "FailoverPriorityChange", nil, "Failure preparing request")
   342  		return
   343  	}
   344  
   345  	result, err = client.FailoverPriorityChangeSender(req)
   346  	if err != nil {
   347  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "FailoverPriorityChange", result.Response(), "Failure sending request")
   348  		return
   349  	}
   350  
   351  	return
   352  }
   353  
   354  // FailoverPriorityChangePreparer prepares the FailoverPriorityChange request.
   355  func (client DatabaseAccountsClient) FailoverPriorityChangePreparer(ctx context.Context, resourceGroupName string, accountName string, failoverParameters FailoverPolicies) (*http.Request, error) {
   356  	pathParameters := map[string]interface{}{
   357  		"accountName":       autorest.Encode("path", accountName),
   358  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   359  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   360  	}
   361  
   362  	const APIVersion = "2021-04-01-preview"
   363  	queryParameters := map[string]interface{}{
   364  		"api-version": APIVersion,
   365  	}
   366  
   367  	preparer := autorest.CreatePreparer(
   368  		autorest.AsContentType("application/json; charset=utf-8"),
   369  		autorest.AsPost(),
   370  		autorest.WithBaseURL(client.BaseURI),
   371  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/failoverPriorityChange", pathParameters),
   372  		autorest.WithJSON(failoverParameters),
   373  		autorest.WithQueryParameters(queryParameters))
   374  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   375  }
   376  
   377  // FailoverPriorityChangeSender sends the FailoverPriorityChange request. The method will close the
   378  // http.Response Body if it receives an error.
   379  func (client DatabaseAccountsClient) FailoverPriorityChangeSender(req *http.Request) (future DatabaseAccountsFailoverPriorityChangeFuture, err error) {
   380  	var resp *http.Response
   381  	future.FutureAPI = &azure.Future{}
   382  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   383  	if err != nil {
   384  		return
   385  	}
   386  	var azf azure.Future
   387  	azf, err = azure.NewFutureFromResponse(resp)
   388  	future.FutureAPI = &azf
   389  	future.Result = future.result
   390  	return
   391  }
   392  
   393  // FailoverPriorityChangeResponder handles the response to the FailoverPriorityChange request. The method always
   394  // closes the http.Response Body.
   395  func (client DatabaseAccountsClient) FailoverPriorityChangeResponder(resp *http.Response) (result autorest.Response, err error) {
   396  	err = autorest.Respond(
   397  		resp,
   398  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   399  		autorest.ByClosing())
   400  	result.Response = resp
   401  	return
   402  }
   403  
   404  // Get retrieves the properties of an existing Azure Cosmos DB database account.
   405  // Parameters:
   406  // resourceGroupName - the name of the resource group. The name is case insensitive.
   407  // accountName - cosmos DB database account name.
   408  func (client DatabaseAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountGetResults, err error) {
   409  	if tracing.IsEnabled() {
   410  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Get")
   411  		defer func() {
   412  			sc := -1
   413  			if result.Response.Response != nil {
   414  				sc = result.Response.Response.StatusCode
   415  			}
   416  			tracing.EndSpan(ctx, sc, err)
   417  		}()
   418  	}
   419  	if err := validation.Validate([]validation.Validation{
   420  		{TargetValue: client.SubscriptionID,
   421  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   422  		{TargetValue: resourceGroupName,
   423  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   424  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   425  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   426  		{TargetValue: accountName,
   427  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   428  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   429  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   430  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Get", err.Error())
   431  	}
   432  
   433  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
   434  	if err != nil {
   435  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", nil, "Failure preparing request")
   436  		return
   437  	}
   438  
   439  	resp, err := client.GetSender(req)
   440  	if err != nil {
   441  		result.Response = autorest.Response{Response: resp}
   442  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", resp, "Failure sending request")
   443  		return
   444  	}
   445  
   446  	result, err = client.GetResponder(resp)
   447  	if err != nil {
   448  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Get", resp, "Failure responding to request")
   449  		return
   450  	}
   451  
   452  	return
   453  }
   454  
   455  // GetPreparer prepares the Get request.
   456  func (client DatabaseAccountsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   457  	pathParameters := map[string]interface{}{
   458  		"accountName":       autorest.Encode("path", accountName),
   459  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   460  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   461  	}
   462  
   463  	const APIVersion = "2021-04-01-preview"
   464  	queryParameters := map[string]interface{}{
   465  		"api-version": APIVersion,
   466  	}
   467  
   468  	preparer := autorest.CreatePreparer(
   469  		autorest.AsGet(),
   470  		autorest.WithBaseURL(client.BaseURI),
   471  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
   472  		autorest.WithQueryParameters(queryParameters))
   473  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   474  }
   475  
   476  // GetSender sends the Get request. The method will close the
   477  // http.Response Body if it receives an error.
   478  func (client DatabaseAccountsClient) GetSender(req *http.Request) (*http.Response, error) {
   479  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   480  }
   481  
   482  // GetResponder handles the response to the Get request. The method always
   483  // closes the http.Response Body.
   484  func (client DatabaseAccountsClient) GetResponder(resp *http.Response) (result DatabaseAccountGetResults, err error) {
   485  	err = autorest.Respond(
   486  		resp,
   487  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   488  		autorest.ByUnmarshallingJSON(&result),
   489  		autorest.ByClosing())
   490  	result.Response = autorest.Response{Response: resp}
   491  	return
   492  }
   493  
   494  // GetReadOnlyKeys lists the read-only access keys for the specified Azure Cosmos DB database account.
   495  // Parameters:
   496  // resourceGroupName - the name of the resource group. The name is case insensitive.
   497  // accountName - cosmos DB database account name.
   498  func (client DatabaseAccountsClient) GetReadOnlyKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListReadOnlyKeysResult, err error) {
   499  	if tracing.IsEnabled() {
   500  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.GetReadOnlyKeys")
   501  		defer func() {
   502  			sc := -1
   503  			if result.Response.Response != nil {
   504  				sc = result.Response.Response.StatusCode
   505  			}
   506  			tracing.EndSpan(ctx, sc, err)
   507  		}()
   508  	}
   509  	if err := validation.Validate([]validation.Validation{
   510  		{TargetValue: client.SubscriptionID,
   511  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   512  		{TargetValue: resourceGroupName,
   513  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   514  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   515  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   516  		{TargetValue: accountName,
   517  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   518  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   519  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   520  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", err.Error())
   521  	}
   522  
   523  	req, err := client.GetReadOnlyKeysPreparer(ctx, resourceGroupName, accountName)
   524  	if err != nil {
   525  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", nil, "Failure preparing request")
   526  		return
   527  	}
   528  
   529  	resp, err := client.GetReadOnlyKeysSender(req)
   530  	if err != nil {
   531  		result.Response = autorest.Response{Response: resp}
   532  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", resp, "Failure sending request")
   533  		return
   534  	}
   535  
   536  	result, err = client.GetReadOnlyKeysResponder(resp)
   537  	if err != nil {
   538  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "GetReadOnlyKeys", resp, "Failure responding to request")
   539  		return
   540  	}
   541  
   542  	return
   543  }
   544  
   545  // GetReadOnlyKeysPreparer prepares the GetReadOnlyKeys request.
   546  func (client DatabaseAccountsClient) GetReadOnlyKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   547  	pathParameters := map[string]interface{}{
   548  		"accountName":       autorest.Encode("path", accountName),
   549  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   550  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   551  	}
   552  
   553  	const APIVersion = "2021-04-01-preview"
   554  	queryParameters := map[string]interface{}{
   555  		"api-version": APIVersion,
   556  	}
   557  
   558  	preparer := autorest.CreatePreparer(
   559  		autorest.AsGet(),
   560  		autorest.WithBaseURL(client.BaseURI),
   561  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/readonlykeys", pathParameters),
   562  		autorest.WithQueryParameters(queryParameters))
   563  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   564  }
   565  
   566  // GetReadOnlyKeysSender sends the GetReadOnlyKeys request. The method will close the
   567  // http.Response Body if it receives an error.
   568  func (client DatabaseAccountsClient) GetReadOnlyKeysSender(req *http.Request) (*http.Response, error) {
   569  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   570  }
   571  
   572  // GetReadOnlyKeysResponder handles the response to the GetReadOnlyKeys request. The method always
   573  // closes the http.Response Body.
   574  func (client DatabaseAccountsClient) GetReadOnlyKeysResponder(resp *http.Response) (result DatabaseAccountListReadOnlyKeysResult, err error) {
   575  	err = autorest.Respond(
   576  		resp,
   577  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   578  		autorest.ByUnmarshallingJSON(&result),
   579  		autorest.ByClosing())
   580  	result.Response = autorest.Response{Response: resp}
   581  	return
   582  }
   583  
   584  // List lists all the Azure Cosmos DB database accounts available under the subscription.
   585  func (client DatabaseAccountsClient) List(ctx context.Context) (result DatabaseAccountsListResult, err error) {
   586  	if tracing.IsEnabled() {
   587  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.List")
   588  		defer func() {
   589  			sc := -1
   590  			if result.Response.Response != nil {
   591  				sc = result.Response.Response.StatusCode
   592  			}
   593  			tracing.EndSpan(ctx, sc, err)
   594  		}()
   595  	}
   596  	if err := validation.Validate([]validation.Validation{
   597  		{TargetValue: client.SubscriptionID,
   598  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   599  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "List", err.Error())
   600  	}
   601  
   602  	req, err := client.ListPreparer(ctx)
   603  	if err != nil {
   604  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", nil, "Failure preparing request")
   605  		return
   606  	}
   607  
   608  	resp, err := client.ListSender(req)
   609  	if err != nil {
   610  		result.Response = autorest.Response{Response: resp}
   611  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", resp, "Failure sending request")
   612  		return
   613  	}
   614  
   615  	result, err = client.ListResponder(resp)
   616  	if err != nil {
   617  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "List", resp, "Failure responding to request")
   618  		return
   619  	}
   620  
   621  	return
   622  }
   623  
   624  // ListPreparer prepares the List request.
   625  func (client DatabaseAccountsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
   626  	pathParameters := map[string]interface{}{
   627  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   628  	}
   629  
   630  	const APIVersion = "2021-04-01-preview"
   631  	queryParameters := map[string]interface{}{
   632  		"api-version": APIVersion,
   633  	}
   634  
   635  	preparer := autorest.CreatePreparer(
   636  		autorest.AsGet(),
   637  		autorest.WithBaseURL(client.BaseURI),
   638  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/databaseAccounts", pathParameters),
   639  		autorest.WithQueryParameters(queryParameters))
   640  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   641  }
   642  
   643  // ListSender sends the List request. The method will close the
   644  // http.Response Body if it receives an error.
   645  func (client DatabaseAccountsClient) ListSender(req *http.Request) (*http.Response, error) {
   646  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   647  }
   648  
   649  // ListResponder handles the response to the List request. The method always
   650  // closes the http.Response Body.
   651  func (client DatabaseAccountsClient) ListResponder(resp *http.Response) (result DatabaseAccountsListResult, err error) {
   652  	err = autorest.Respond(
   653  		resp,
   654  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   655  		autorest.ByUnmarshallingJSON(&result),
   656  		autorest.ByClosing())
   657  	result.Response = autorest.Response{Response: resp}
   658  	return
   659  }
   660  
   661  // ListByResourceGroup lists all the Azure Cosmos DB database accounts available under the given resource group.
   662  // Parameters:
   663  // resourceGroupName - the name of the resource group. The name is case insensitive.
   664  func (client DatabaseAccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result DatabaseAccountsListResult, err error) {
   665  	if tracing.IsEnabled() {
   666  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListByResourceGroup")
   667  		defer func() {
   668  			sc := -1
   669  			if result.Response.Response != nil {
   670  				sc = result.Response.Response.StatusCode
   671  			}
   672  			tracing.EndSpan(ctx, sc, err)
   673  		}()
   674  	}
   675  	if err := validation.Validate([]validation.Validation{
   676  		{TargetValue: resourceGroupName,
   677  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   678  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   679  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   680  		{TargetValue: client.SubscriptionID,
   681  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   682  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListByResourceGroup", err.Error())
   683  	}
   684  
   685  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
   686  	if err != nil {
   687  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", nil, "Failure preparing request")
   688  		return
   689  	}
   690  
   691  	resp, err := client.ListByResourceGroupSender(req)
   692  	if err != nil {
   693  		result.Response = autorest.Response{Response: resp}
   694  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", resp, "Failure sending request")
   695  		return
   696  	}
   697  
   698  	result, err = client.ListByResourceGroupResponder(resp)
   699  	if err != nil {
   700  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListByResourceGroup", resp, "Failure responding to request")
   701  		return
   702  	}
   703  
   704  	return
   705  }
   706  
   707  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   708  func (client DatabaseAccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   709  	pathParameters := map[string]interface{}{
   710  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   711  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   712  	}
   713  
   714  	const APIVersion = "2021-04-01-preview"
   715  	queryParameters := map[string]interface{}{
   716  		"api-version": APIVersion,
   717  	}
   718  
   719  	preparer := autorest.CreatePreparer(
   720  		autorest.AsGet(),
   721  		autorest.WithBaseURL(client.BaseURI),
   722  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts", pathParameters),
   723  		autorest.WithQueryParameters(queryParameters))
   724  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   725  }
   726  
   727  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   728  // http.Response Body if it receives an error.
   729  func (client DatabaseAccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   730  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   731  }
   732  
   733  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   734  // closes the http.Response Body.
   735  func (client DatabaseAccountsClient) ListByResourceGroupResponder(resp *http.Response) (result DatabaseAccountsListResult, err error) {
   736  	err = autorest.Respond(
   737  		resp,
   738  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   739  		autorest.ByUnmarshallingJSON(&result),
   740  		autorest.ByClosing())
   741  	result.Response = autorest.Response{Response: resp}
   742  	return
   743  }
   744  
   745  // ListConnectionStrings lists the connection strings for the specified Azure Cosmos DB database account.
   746  // Parameters:
   747  // resourceGroupName - the name of the resource group. The name is case insensitive.
   748  // accountName - cosmos DB database account name.
   749  func (client DatabaseAccountsClient) ListConnectionStrings(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListConnectionStringsResult, err error) {
   750  	if tracing.IsEnabled() {
   751  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListConnectionStrings")
   752  		defer func() {
   753  			sc := -1
   754  			if result.Response.Response != nil {
   755  				sc = result.Response.Response.StatusCode
   756  			}
   757  			tracing.EndSpan(ctx, sc, err)
   758  		}()
   759  	}
   760  	if err := validation.Validate([]validation.Validation{
   761  		{TargetValue: client.SubscriptionID,
   762  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   763  		{TargetValue: resourceGroupName,
   764  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   765  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   766  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   767  		{TargetValue: accountName,
   768  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   769  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   770  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   771  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListConnectionStrings", err.Error())
   772  	}
   773  
   774  	req, err := client.ListConnectionStringsPreparer(ctx, resourceGroupName, accountName)
   775  	if err != nil {
   776  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", nil, "Failure preparing request")
   777  		return
   778  	}
   779  
   780  	resp, err := client.ListConnectionStringsSender(req)
   781  	if err != nil {
   782  		result.Response = autorest.Response{Response: resp}
   783  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", resp, "Failure sending request")
   784  		return
   785  	}
   786  
   787  	result, err = client.ListConnectionStringsResponder(resp)
   788  	if err != nil {
   789  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListConnectionStrings", resp, "Failure responding to request")
   790  		return
   791  	}
   792  
   793  	return
   794  }
   795  
   796  // ListConnectionStringsPreparer prepares the ListConnectionStrings request.
   797  func (client DatabaseAccountsClient) ListConnectionStringsPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   798  	pathParameters := map[string]interface{}{
   799  		"accountName":       autorest.Encode("path", accountName),
   800  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   801  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   802  	}
   803  
   804  	const APIVersion = "2021-04-01-preview"
   805  	queryParameters := map[string]interface{}{
   806  		"api-version": APIVersion,
   807  	}
   808  
   809  	preparer := autorest.CreatePreparer(
   810  		autorest.AsPost(),
   811  		autorest.WithBaseURL(client.BaseURI),
   812  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/listConnectionStrings", pathParameters),
   813  		autorest.WithQueryParameters(queryParameters))
   814  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   815  }
   816  
   817  // ListConnectionStringsSender sends the ListConnectionStrings request. The method will close the
   818  // http.Response Body if it receives an error.
   819  func (client DatabaseAccountsClient) ListConnectionStringsSender(req *http.Request) (*http.Response, error) {
   820  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   821  }
   822  
   823  // ListConnectionStringsResponder handles the response to the ListConnectionStrings request. The method always
   824  // closes the http.Response Body.
   825  func (client DatabaseAccountsClient) ListConnectionStringsResponder(resp *http.Response) (result DatabaseAccountListConnectionStringsResult, err error) {
   826  	err = autorest.Respond(
   827  		resp,
   828  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   829  		autorest.ByUnmarshallingJSON(&result),
   830  		autorest.ByClosing())
   831  	result.Response = autorest.Response{Response: resp}
   832  	return
   833  }
   834  
   835  // ListKeys lists the access keys for the specified Azure Cosmos DB database account.
   836  // Parameters:
   837  // resourceGroupName - the name of the resource group. The name is case insensitive.
   838  // accountName - cosmos DB database account name.
   839  func (client DatabaseAccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListKeysResult, err error) {
   840  	if tracing.IsEnabled() {
   841  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListKeys")
   842  		defer func() {
   843  			sc := -1
   844  			if result.Response.Response != nil {
   845  				sc = result.Response.Response.StatusCode
   846  			}
   847  			tracing.EndSpan(ctx, sc, err)
   848  		}()
   849  	}
   850  	if err := validation.Validate([]validation.Validation{
   851  		{TargetValue: client.SubscriptionID,
   852  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   853  		{TargetValue: resourceGroupName,
   854  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   855  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   856  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   857  		{TargetValue: accountName,
   858  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   859  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   860  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   861  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListKeys", err.Error())
   862  	}
   863  
   864  	req, err := client.ListKeysPreparer(ctx, resourceGroupName, accountName)
   865  	if err != nil {
   866  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", nil, "Failure preparing request")
   867  		return
   868  	}
   869  
   870  	resp, err := client.ListKeysSender(req)
   871  	if err != nil {
   872  		result.Response = autorest.Response{Response: resp}
   873  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", resp, "Failure sending request")
   874  		return
   875  	}
   876  
   877  	result, err = client.ListKeysResponder(resp)
   878  	if err != nil {
   879  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListKeys", resp, "Failure responding to request")
   880  		return
   881  	}
   882  
   883  	return
   884  }
   885  
   886  // ListKeysPreparer prepares the ListKeys request.
   887  func (client DatabaseAccountsClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   888  	pathParameters := map[string]interface{}{
   889  		"accountName":       autorest.Encode("path", accountName),
   890  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   891  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   892  	}
   893  
   894  	const APIVersion = "2021-04-01-preview"
   895  	queryParameters := map[string]interface{}{
   896  		"api-version": APIVersion,
   897  	}
   898  
   899  	preparer := autorest.CreatePreparer(
   900  		autorest.AsPost(),
   901  		autorest.WithBaseURL(client.BaseURI),
   902  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/listKeys", pathParameters),
   903  		autorest.WithQueryParameters(queryParameters))
   904  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   905  }
   906  
   907  // ListKeysSender sends the ListKeys request. The method will close the
   908  // http.Response Body if it receives an error.
   909  func (client DatabaseAccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) {
   910  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   911  }
   912  
   913  // ListKeysResponder handles the response to the ListKeys request. The method always
   914  // closes the http.Response Body.
   915  func (client DatabaseAccountsClient) ListKeysResponder(resp *http.Response) (result DatabaseAccountListKeysResult, err error) {
   916  	err = autorest.Respond(
   917  		resp,
   918  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   919  		autorest.ByUnmarshallingJSON(&result),
   920  		autorest.ByClosing())
   921  	result.Response = autorest.Response{Response: resp}
   922  	return
   923  }
   924  
   925  // ListMetricDefinitions retrieves metric definitions for the given database account.
   926  // Parameters:
   927  // resourceGroupName - the name of the resource group. The name is case insensitive.
   928  // accountName - cosmos DB database account name.
   929  func (client DatabaseAccountsClient) ListMetricDefinitions(ctx context.Context, resourceGroupName string, accountName string) (result MetricDefinitionsListResult, err error) {
   930  	if tracing.IsEnabled() {
   931  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMetricDefinitions")
   932  		defer func() {
   933  			sc := -1
   934  			if result.Response.Response != nil {
   935  				sc = result.Response.Response.StatusCode
   936  			}
   937  			tracing.EndSpan(ctx, sc, err)
   938  		}()
   939  	}
   940  	if err := validation.Validate([]validation.Validation{
   941  		{TargetValue: client.SubscriptionID,
   942  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   943  		{TargetValue: resourceGroupName,
   944  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   945  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   946  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   947  		{TargetValue: accountName,
   948  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   949  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
   950  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
   951  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMetricDefinitions", err.Error())
   952  	}
   953  
   954  	req, err := client.ListMetricDefinitionsPreparer(ctx, resourceGroupName, accountName)
   955  	if err != nil {
   956  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", nil, "Failure preparing request")
   957  		return
   958  	}
   959  
   960  	resp, err := client.ListMetricDefinitionsSender(req)
   961  	if err != nil {
   962  		result.Response = autorest.Response{Response: resp}
   963  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", resp, "Failure sending request")
   964  		return
   965  	}
   966  
   967  	result, err = client.ListMetricDefinitionsResponder(resp)
   968  	if err != nil {
   969  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetricDefinitions", resp, "Failure responding to request")
   970  		return
   971  	}
   972  
   973  	return
   974  }
   975  
   976  // ListMetricDefinitionsPreparer prepares the ListMetricDefinitions request.
   977  func (client DatabaseAccountsClient) ListMetricDefinitionsPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   978  	pathParameters := map[string]interface{}{
   979  		"accountName":       autorest.Encode("path", accountName),
   980  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   981  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   982  	}
   983  
   984  	const APIVersion = "2021-04-01-preview"
   985  	queryParameters := map[string]interface{}{
   986  		"api-version": APIVersion,
   987  	}
   988  
   989  	preparer := autorest.CreatePreparer(
   990  		autorest.AsGet(),
   991  		autorest.WithBaseURL(client.BaseURI),
   992  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/metricDefinitions", pathParameters),
   993  		autorest.WithQueryParameters(queryParameters))
   994  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   995  }
   996  
   997  // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the
   998  // http.Response Body if it receives an error.
   999  func (client DatabaseAccountsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
  1000  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1001  }
  1002  
  1003  // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always
  1004  // closes the http.Response Body.
  1005  func (client DatabaseAccountsClient) ListMetricDefinitionsResponder(resp *http.Response) (result MetricDefinitionsListResult, err error) {
  1006  	err = autorest.Respond(
  1007  		resp,
  1008  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1009  		autorest.ByUnmarshallingJSON(&result),
  1010  		autorest.ByClosing())
  1011  	result.Response = autorest.Response{Response: resp}
  1012  	return
  1013  }
  1014  
  1015  // ListMetrics retrieves the metrics determined by the given filter for the given database account.
  1016  // Parameters:
  1017  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1018  // accountName - cosmos DB database account name.
  1019  // filter - an OData filter expression that describes a subset of metrics to return. The parameters that can be
  1020  // filtered are name.value (name of the metric, can have an or of multiple names), startTime, endTime, and
  1021  // timeGrain. The supported operator is eq.
  1022  func (client DatabaseAccountsClient) ListMetrics(ctx context.Context, resourceGroupName string, accountName string, filter string) (result MetricListResult, err error) {
  1023  	if tracing.IsEnabled() {
  1024  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListMetrics")
  1025  		defer func() {
  1026  			sc := -1
  1027  			if result.Response.Response != nil {
  1028  				sc = result.Response.Response.StatusCode
  1029  			}
  1030  			tracing.EndSpan(ctx, sc, err)
  1031  		}()
  1032  	}
  1033  	if err := validation.Validate([]validation.Validation{
  1034  		{TargetValue: client.SubscriptionID,
  1035  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1036  		{TargetValue: resourceGroupName,
  1037  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1038  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1039  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1040  		{TargetValue: accountName,
  1041  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1042  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1043  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1044  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListMetrics", err.Error())
  1045  	}
  1046  
  1047  	req, err := client.ListMetricsPreparer(ctx, resourceGroupName, accountName, filter)
  1048  	if err != nil {
  1049  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", nil, "Failure preparing request")
  1050  		return
  1051  	}
  1052  
  1053  	resp, err := client.ListMetricsSender(req)
  1054  	if err != nil {
  1055  		result.Response = autorest.Response{Response: resp}
  1056  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", resp, "Failure sending request")
  1057  		return
  1058  	}
  1059  
  1060  	result, err = client.ListMetricsResponder(resp)
  1061  	if err != nil {
  1062  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListMetrics", resp, "Failure responding to request")
  1063  		return
  1064  	}
  1065  
  1066  	return
  1067  }
  1068  
  1069  // ListMetricsPreparer prepares the ListMetrics request.
  1070  func (client DatabaseAccountsClient) ListMetricsPreparer(ctx context.Context, resourceGroupName string, accountName string, filter string) (*http.Request, error) {
  1071  	pathParameters := map[string]interface{}{
  1072  		"accountName":       autorest.Encode("path", accountName),
  1073  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1074  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1075  	}
  1076  
  1077  	const APIVersion = "2021-04-01-preview"
  1078  	queryParameters := map[string]interface{}{
  1079  		"$filter":     autorest.Encode("query", filter),
  1080  		"api-version": APIVersion,
  1081  	}
  1082  
  1083  	preparer := autorest.CreatePreparer(
  1084  		autorest.AsGet(),
  1085  		autorest.WithBaseURL(client.BaseURI),
  1086  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/metrics", pathParameters),
  1087  		autorest.WithQueryParameters(queryParameters))
  1088  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1089  }
  1090  
  1091  // ListMetricsSender sends the ListMetrics request. The method will close the
  1092  // http.Response Body if it receives an error.
  1093  func (client DatabaseAccountsClient) ListMetricsSender(req *http.Request) (*http.Response, error) {
  1094  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1095  }
  1096  
  1097  // ListMetricsResponder handles the response to the ListMetrics request. The method always
  1098  // closes the http.Response Body.
  1099  func (client DatabaseAccountsClient) ListMetricsResponder(resp *http.Response) (result MetricListResult, err error) {
  1100  	err = autorest.Respond(
  1101  		resp,
  1102  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1103  		autorest.ByUnmarshallingJSON(&result),
  1104  		autorest.ByClosing())
  1105  	result.Response = autorest.Response{Response: resp}
  1106  	return
  1107  }
  1108  
  1109  // ListReadOnlyKeys lists the read-only access keys for the specified Azure Cosmos DB database account.
  1110  // Parameters:
  1111  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1112  // accountName - cosmos DB database account name.
  1113  func (client DatabaseAccountsClient) ListReadOnlyKeys(ctx context.Context, resourceGroupName string, accountName string) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  1114  	if tracing.IsEnabled() {
  1115  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListReadOnlyKeys")
  1116  		defer func() {
  1117  			sc := -1
  1118  			if result.Response.Response != nil {
  1119  				sc = result.Response.Response.StatusCode
  1120  			}
  1121  			tracing.EndSpan(ctx, sc, err)
  1122  		}()
  1123  	}
  1124  	if err := validation.Validate([]validation.Validation{
  1125  		{TargetValue: client.SubscriptionID,
  1126  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1127  		{TargetValue: resourceGroupName,
  1128  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1129  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1130  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1131  		{TargetValue: accountName,
  1132  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1133  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1134  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1135  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", err.Error())
  1136  	}
  1137  
  1138  	req, err := client.ListReadOnlyKeysPreparer(ctx, resourceGroupName, accountName)
  1139  	if err != nil {
  1140  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", nil, "Failure preparing request")
  1141  		return
  1142  	}
  1143  
  1144  	resp, err := client.ListReadOnlyKeysSender(req)
  1145  	if err != nil {
  1146  		result.Response = autorest.Response{Response: resp}
  1147  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", resp, "Failure sending request")
  1148  		return
  1149  	}
  1150  
  1151  	result, err = client.ListReadOnlyKeysResponder(resp)
  1152  	if err != nil {
  1153  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListReadOnlyKeys", resp, "Failure responding to request")
  1154  		return
  1155  	}
  1156  
  1157  	return
  1158  }
  1159  
  1160  // ListReadOnlyKeysPreparer prepares the ListReadOnlyKeys request.
  1161  func (client DatabaseAccountsClient) ListReadOnlyKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
  1162  	pathParameters := map[string]interface{}{
  1163  		"accountName":       autorest.Encode("path", accountName),
  1164  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1165  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1166  	}
  1167  
  1168  	const APIVersion = "2021-04-01-preview"
  1169  	queryParameters := map[string]interface{}{
  1170  		"api-version": APIVersion,
  1171  	}
  1172  
  1173  	preparer := autorest.CreatePreparer(
  1174  		autorest.AsPost(),
  1175  		autorest.WithBaseURL(client.BaseURI),
  1176  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/readonlykeys", pathParameters),
  1177  		autorest.WithQueryParameters(queryParameters))
  1178  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1179  }
  1180  
  1181  // ListReadOnlyKeysSender sends the ListReadOnlyKeys request. The method will close the
  1182  // http.Response Body if it receives an error.
  1183  func (client DatabaseAccountsClient) ListReadOnlyKeysSender(req *http.Request) (*http.Response, error) {
  1184  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1185  }
  1186  
  1187  // ListReadOnlyKeysResponder handles the response to the ListReadOnlyKeys request. The method always
  1188  // closes the http.Response Body.
  1189  func (client DatabaseAccountsClient) ListReadOnlyKeysResponder(resp *http.Response) (result DatabaseAccountListReadOnlyKeysResult, err error) {
  1190  	err = autorest.Respond(
  1191  		resp,
  1192  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1193  		autorest.ByUnmarshallingJSON(&result),
  1194  		autorest.ByClosing())
  1195  	result.Response = autorest.Response{Response: resp}
  1196  	return
  1197  }
  1198  
  1199  // ListUsages retrieves the usages (most recent data) for the given database account.
  1200  // Parameters:
  1201  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1202  // accountName - cosmos DB database account name.
  1203  // filter - an OData filter expression that describes a subset of usages to return. The supported parameter is
  1204  // name.value (name of the metric, can have an or of multiple names).
  1205  func (client DatabaseAccountsClient) ListUsages(ctx context.Context, resourceGroupName string, accountName string, filter string) (result UsagesResult, err error) {
  1206  	if tracing.IsEnabled() {
  1207  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.ListUsages")
  1208  		defer func() {
  1209  			sc := -1
  1210  			if result.Response.Response != nil {
  1211  				sc = result.Response.Response.StatusCode
  1212  			}
  1213  			tracing.EndSpan(ctx, sc, err)
  1214  		}()
  1215  	}
  1216  	if err := validation.Validate([]validation.Validation{
  1217  		{TargetValue: client.SubscriptionID,
  1218  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1219  		{TargetValue: resourceGroupName,
  1220  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1221  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1222  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1223  		{TargetValue: accountName,
  1224  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1225  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1226  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1227  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "ListUsages", err.Error())
  1228  	}
  1229  
  1230  	req, err := client.ListUsagesPreparer(ctx, resourceGroupName, accountName, filter)
  1231  	if err != nil {
  1232  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", nil, "Failure preparing request")
  1233  		return
  1234  	}
  1235  
  1236  	resp, err := client.ListUsagesSender(req)
  1237  	if err != nil {
  1238  		result.Response = autorest.Response{Response: resp}
  1239  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", resp, "Failure sending request")
  1240  		return
  1241  	}
  1242  
  1243  	result, err = client.ListUsagesResponder(resp)
  1244  	if err != nil {
  1245  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "ListUsages", resp, "Failure responding to request")
  1246  		return
  1247  	}
  1248  
  1249  	return
  1250  }
  1251  
  1252  // ListUsagesPreparer prepares the ListUsages request.
  1253  func (client DatabaseAccountsClient) ListUsagesPreparer(ctx context.Context, resourceGroupName string, accountName string, filter string) (*http.Request, error) {
  1254  	pathParameters := map[string]interface{}{
  1255  		"accountName":       autorest.Encode("path", accountName),
  1256  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1257  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1258  	}
  1259  
  1260  	const APIVersion = "2021-04-01-preview"
  1261  	queryParameters := map[string]interface{}{
  1262  		"api-version": APIVersion,
  1263  	}
  1264  	if len(filter) > 0 {
  1265  		queryParameters["$filter"] = autorest.Encode("query", filter)
  1266  	}
  1267  
  1268  	preparer := autorest.CreatePreparer(
  1269  		autorest.AsGet(),
  1270  		autorest.WithBaseURL(client.BaseURI),
  1271  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/usages", pathParameters),
  1272  		autorest.WithQueryParameters(queryParameters))
  1273  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1274  }
  1275  
  1276  // ListUsagesSender sends the ListUsages request. The method will close the
  1277  // http.Response Body if it receives an error.
  1278  func (client DatabaseAccountsClient) ListUsagesSender(req *http.Request) (*http.Response, error) {
  1279  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1280  }
  1281  
  1282  // ListUsagesResponder handles the response to the ListUsages request. The method always
  1283  // closes the http.Response Body.
  1284  func (client DatabaseAccountsClient) ListUsagesResponder(resp *http.Response) (result UsagesResult, err error) {
  1285  	err = autorest.Respond(
  1286  		resp,
  1287  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1288  		autorest.ByUnmarshallingJSON(&result),
  1289  		autorest.ByClosing())
  1290  	result.Response = autorest.Response{Response: resp}
  1291  	return
  1292  }
  1293  
  1294  // OfflineRegion offline the specified region for the specified Azure Cosmos DB database account.
  1295  // Parameters:
  1296  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1297  // accountName - cosmos DB database account name.
  1298  // regionParameterForOffline - cosmos DB region to offline for the database account.
  1299  func (client DatabaseAccountsClient) OfflineRegion(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOffline RegionForOnlineOffline) (result DatabaseAccountsOfflineRegionFuture, err error) {
  1300  	if tracing.IsEnabled() {
  1301  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.OfflineRegion")
  1302  		defer func() {
  1303  			sc := -1
  1304  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1305  				sc = result.FutureAPI.Response().StatusCode
  1306  			}
  1307  			tracing.EndSpan(ctx, sc, err)
  1308  		}()
  1309  	}
  1310  	if err := validation.Validate([]validation.Validation{
  1311  		{TargetValue: client.SubscriptionID,
  1312  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1313  		{TargetValue: resourceGroupName,
  1314  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1315  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1316  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1317  		{TargetValue: accountName,
  1318  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1319  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1320  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  1321  		{TargetValue: regionParameterForOffline,
  1322  			Constraints: []validation.Constraint{{Target: "regionParameterForOffline.Region", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1323  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "OfflineRegion", err.Error())
  1324  	}
  1325  
  1326  	req, err := client.OfflineRegionPreparer(ctx, resourceGroupName, accountName, regionParameterForOffline)
  1327  	if err != nil {
  1328  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OfflineRegion", nil, "Failure preparing request")
  1329  		return
  1330  	}
  1331  
  1332  	result, err = client.OfflineRegionSender(req)
  1333  	if err != nil {
  1334  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OfflineRegion", result.Response(), "Failure sending request")
  1335  		return
  1336  	}
  1337  
  1338  	return
  1339  }
  1340  
  1341  // OfflineRegionPreparer prepares the OfflineRegion request.
  1342  func (client DatabaseAccountsClient) OfflineRegionPreparer(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOffline RegionForOnlineOffline) (*http.Request, error) {
  1343  	pathParameters := map[string]interface{}{
  1344  		"accountName":       autorest.Encode("path", accountName),
  1345  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1346  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1347  	}
  1348  
  1349  	const APIVersion = "2021-04-01-preview"
  1350  	queryParameters := map[string]interface{}{
  1351  		"api-version": APIVersion,
  1352  	}
  1353  
  1354  	preparer := autorest.CreatePreparer(
  1355  		autorest.AsContentType("application/json; charset=utf-8"),
  1356  		autorest.AsPost(),
  1357  		autorest.WithBaseURL(client.BaseURI),
  1358  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/offlineRegion", pathParameters),
  1359  		autorest.WithJSON(regionParameterForOffline),
  1360  		autorest.WithQueryParameters(queryParameters))
  1361  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1362  }
  1363  
  1364  // OfflineRegionSender sends the OfflineRegion request. The method will close the
  1365  // http.Response Body if it receives an error.
  1366  func (client DatabaseAccountsClient) OfflineRegionSender(req *http.Request) (future DatabaseAccountsOfflineRegionFuture, err error) {
  1367  	var resp *http.Response
  1368  	future.FutureAPI = &azure.Future{}
  1369  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1370  	if err != nil {
  1371  		return
  1372  	}
  1373  	var azf azure.Future
  1374  	azf, err = azure.NewFutureFromResponse(resp)
  1375  	future.FutureAPI = &azf
  1376  	future.Result = future.result
  1377  	return
  1378  }
  1379  
  1380  // OfflineRegionResponder handles the response to the OfflineRegion request. The method always
  1381  // closes the http.Response Body.
  1382  func (client DatabaseAccountsClient) OfflineRegionResponder(resp *http.Response) (result autorest.Response, err error) {
  1383  	err = autorest.Respond(
  1384  		resp,
  1385  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1386  		autorest.ByClosing())
  1387  	result.Response = resp
  1388  	return
  1389  }
  1390  
  1391  // OnlineRegion online the specified region for the specified Azure Cosmos DB database account.
  1392  // Parameters:
  1393  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1394  // accountName - cosmos DB database account name.
  1395  // regionParameterForOnline - cosmos DB region to online for the database account.
  1396  func (client DatabaseAccountsClient) OnlineRegion(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOnline RegionForOnlineOffline) (result DatabaseAccountsOnlineRegionFuture, err error) {
  1397  	if tracing.IsEnabled() {
  1398  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.OnlineRegion")
  1399  		defer func() {
  1400  			sc := -1
  1401  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1402  				sc = result.FutureAPI.Response().StatusCode
  1403  			}
  1404  			tracing.EndSpan(ctx, sc, err)
  1405  		}()
  1406  	}
  1407  	if err := validation.Validate([]validation.Validation{
  1408  		{TargetValue: client.SubscriptionID,
  1409  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1410  		{TargetValue: resourceGroupName,
  1411  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1412  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1413  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1414  		{TargetValue: accountName,
  1415  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1416  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1417  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}},
  1418  		{TargetValue: regionParameterForOnline,
  1419  			Constraints: []validation.Constraint{{Target: "regionParameterForOnline.Region", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1420  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "OnlineRegion", err.Error())
  1421  	}
  1422  
  1423  	req, err := client.OnlineRegionPreparer(ctx, resourceGroupName, accountName, regionParameterForOnline)
  1424  	if err != nil {
  1425  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OnlineRegion", nil, "Failure preparing request")
  1426  		return
  1427  	}
  1428  
  1429  	result, err = client.OnlineRegionSender(req)
  1430  	if err != nil {
  1431  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "OnlineRegion", result.Response(), "Failure sending request")
  1432  		return
  1433  	}
  1434  
  1435  	return
  1436  }
  1437  
  1438  // OnlineRegionPreparer prepares the OnlineRegion request.
  1439  func (client DatabaseAccountsClient) OnlineRegionPreparer(ctx context.Context, resourceGroupName string, accountName string, regionParameterForOnline RegionForOnlineOffline) (*http.Request, error) {
  1440  	pathParameters := map[string]interface{}{
  1441  		"accountName":       autorest.Encode("path", accountName),
  1442  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1443  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1444  	}
  1445  
  1446  	const APIVersion = "2021-04-01-preview"
  1447  	queryParameters := map[string]interface{}{
  1448  		"api-version": APIVersion,
  1449  	}
  1450  
  1451  	preparer := autorest.CreatePreparer(
  1452  		autorest.AsContentType("application/json; charset=utf-8"),
  1453  		autorest.AsPost(),
  1454  		autorest.WithBaseURL(client.BaseURI),
  1455  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/onlineRegion", pathParameters),
  1456  		autorest.WithJSON(regionParameterForOnline),
  1457  		autorest.WithQueryParameters(queryParameters))
  1458  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1459  }
  1460  
  1461  // OnlineRegionSender sends the OnlineRegion request. The method will close the
  1462  // http.Response Body if it receives an error.
  1463  func (client DatabaseAccountsClient) OnlineRegionSender(req *http.Request) (future DatabaseAccountsOnlineRegionFuture, err error) {
  1464  	var resp *http.Response
  1465  	future.FutureAPI = &azure.Future{}
  1466  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1467  	if err != nil {
  1468  		return
  1469  	}
  1470  	var azf azure.Future
  1471  	azf, err = azure.NewFutureFromResponse(resp)
  1472  	future.FutureAPI = &azf
  1473  	future.Result = future.result
  1474  	return
  1475  }
  1476  
  1477  // OnlineRegionResponder handles the response to the OnlineRegion request. The method always
  1478  // closes the http.Response Body.
  1479  func (client DatabaseAccountsClient) OnlineRegionResponder(resp *http.Response) (result autorest.Response, err error) {
  1480  	err = autorest.Respond(
  1481  		resp,
  1482  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1483  		autorest.ByClosing())
  1484  	result.Response = resp
  1485  	return
  1486  }
  1487  
  1488  // RegenerateKey regenerates an access key for the specified Azure Cosmos DB database account.
  1489  // Parameters:
  1490  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1491  // accountName - cosmos DB database account name.
  1492  // keyToRegenerate - the name of the key to regenerate.
  1493  func (client DatabaseAccountsClient) RegenerateKey(ctx context.Context, resourceGroupName string, accountName string, keyToRegenerate DatabaseAccountRegenerateKeyParameters) (result DatabaseAccountsRegenerateKeyFuture, err error) {
  1494  	if tracing.IsEnabled() {
  1495  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.RegenerateKey")
  1496  		defer func() {
  1497  			sc := -1
  1498  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1499  				sc = result.FutureAPI.Response().StatusCode
  1500  			}
  1501  			tracing.EndSpan(ctx, sc, err)
  1502  		}()
  1503  	}
  1504  	if err := validation.Validate([]validation.Validation{
  1505  		{TargetValue: client.SubscriptionID,
  1506  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1507  		{TargetValue: resourceGroupName,
  1508  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1509  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1510  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1511  		{TargetValue: accountName,
  1512  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1513  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1514  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1515  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "RegenerateKey", err.Error())
  1516  	}
  1517  
  1518  	req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, accountName, keyToRegenerate)
  1519  	if err != nil {
  1520  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "RegenerateKey", nil, "Failure preparing request")
  1521  		return
  1522  	}
  1523  
  1524  	result, err = client.RegenerateKeySender(req)
  1525  	if err != nil {
  1526  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "RegenerateKey", result.Response(), "Failure sending request")
  1527  		return
  1528  	}
  1529  
  1530  	return
  1531  }
  1532  
  1533  // RegenerateKeyPreparer prepares the RegenerateKey request.
  1534  func (client DatabaseAccountsClient) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, accountName string, keyToRegenerate DatabaseAccountRegenerateKeyParameters) (*http.Request, error) {
  1535  	pathParameters := map[string]interface{}{
  1536  		"accountName":       autorest.Encode("path", accountName),
  1537  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1538  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1539  	}
  1540  
  1541  	const APIVersion = "2021-04-01-preview"
  1542  	queryParameters := map[string]interface{}{
  1543  		"api-version": APIVersion,
  1544  	}
  1545  
  1546  	preparer := autorest.CreatePreparer(
  1547  		autorest.AsContentType("application/json; charset=utf-8"),
  1548  		autorest.AsPost(),
  1549  		autorest.WithBaseURL(client.BaseURI),
  1550  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}/regenerateKey", pathParameters),
  1551  		autorest.WithJSON(keyToRegenerate),
  1552  		autorest.WithQueryParameters(queryParameters))
  1553  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1554  }
  1555  
  1556  // RegenerateKeySender sends the RegenerateKey request. The method will close the
  1557  // http.Response Body if it receives an error.
  1558  func (client DatabaseAccountsClient) RegenerateKeySender(req *http.Request) (future DatabaseAccountsRegenerateKeyFuture, err error) {
  1559  	var resp *http.Response
  1560  	future.FutureAPI = &azure.Future{}
  1561  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1562  	if err != nil {
  1563  		return
  1564  	}
  1565  	var azf azure.Future
  1566  	azf, err = azure.NewFutureFromResponse(resp)
  1567  	future.FutureAPI = &azf
  1568  	future.Result = future.result
  1569  	return
  1570  }
  1571  
  1572  // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always
  1573  // closes the http.Response Body.
  1574  func (client DatabaseAccountsClient) RegenerateKeyResponder(resp *http.Response) (result autorest.Response, err error) {
  1575  	err = autorest.Respond(
  1576  		resp,
  1577  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1578  		autorest.ByClosing())
  1579  	result.Response = resp
  1580  	return
  1581  }
  1582  
  1583  // Update updates the properties of an existing Azure Cosmos DB database account.
  1584  // Parameters:
  1585  // resourceGroupName - the name of the resource group. The name is case insensitive.
  1586  // accountName - cosmos DB database account name.
  1587  // updateParameters - the parameters to provide for the current database account.
  1588  func (client DatabaseAccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, updateParameters DatabaseAccountUpdateParameters) (result DatabaseAccountsUpdateFuture, err error) {
  1589  	if tracing.IsEnabled() {
  1590  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabaseAccountsClient.Update")
  1591  		defer func() {
  1592  			sc := -1
  1593  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1594  				sc = result.FutureAPI.Response().StatusCode
  1595  			}
  1596  			tracing.EndSpan(ctx, sc, err)
  1597  		}()
  1598  	}
  1599  	if err := validation.Validate([]validation.Validation{
  1600  		{TargetValue: client.SubscriptionID,
  1601  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1602  		{TargetValue: resourceGroupName,
  1603  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
  1604  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1605  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
  1606  		{TargetValue: accountName,
  1607  			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 50, Chain: nil},
  1608  				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil},
  1609  				{Target: "accountName", Name: validation.Pattern, Rule: `^[a-z0-9]+(-[a-z0-9]+)*`, Chain: nil}}}}); err != nil {
  1610  		return result, validation.NewError("documentdb.DatabaseAccountsClient", "Update", err.Error())
  1611  	}
  1612  
  1613  	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, updateParameters)
  1614  	if err != nil {
  1615  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Update", nil, "Failure preparing request")
  1616  		return
  1617  	}
  1618  
  1619  	result, err = client.UpdateSender(req)
  1620  	if err != nil {
  1621  		err = autorest.NewErrorWithError(err, "documentdb.DatabaseAccountsClient", "Update", result.Response(), "Failure sending request")
  1622  		return
  1623  	}
  1624  
  1625  	return
  1626  }
  1627  
  1628  // UpdatePreparer prepares the Update request.
  1629  func (client DatabaseAccountsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, updateParameters DatabaseAccountUpdateParameters) (*http.Request, error) {
  1630  	pathParameters := map[string]interface{}{
  1631  		"accountName":       autorest.Encode("path", accountName),
  1632  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1633  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1634  	}
  1635  
  1636  	const APIVersion = "2021-04-01-preview"
  1637  	queryParameters := map[string]interface{}{
  1638  		"api-version": APIVersion,
  1639  	}
  1640  
  1641  	preparer := autorest.CreatePreparer(
  1642  		autorest.AsContentType("application/json; charset=utf-8"),
  1643  		autorest.AsPatch(),
  1644  		autorest.WithBaseURL(client.BaseURI),
  1645  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}", pathParameters),
  1646  		autorest.WithJSON(updateParameters),
  1647  		autorest.WithQueryParameters(queryParameters))
  1648  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1649  }
  1650  
  1651  // UpdateSender sends the Update request. The method will close the
  1652  // http.Response Body if it receives an error.
  1653  func (client DatabaseAccountsClient) UpdateSender(req *http.Request) (future DatabaseAccountsUpdateFuture, err error) {
  1654  	var resp *http.Response
  1655  	future.FutureAPI = &azure.Future{}
  1656  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1657  	if err != nil {
  1658  		return
  1659  	}
  1660  	var azf azure.Future
  1661  	azf, err = azure.NewFutureFromResponse(resp)
  1662  	future.FutureAPI = &azf
  1663  	future.Result = future.result
  1664  	return
  1665  }
  1666  
  1667  // UpdateResponder handles the response to the Update request. The method always
  1668  // closes the http.Response Body.
  1669  func (client DatabaseAccountsClient) UpdateResponder(resp *http.Response) (result DatabaseAccountGetResults, err error) {
  1670  	err = autorest.Respond(
  1671  		resp,
  1672  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1673  		autorest.ByUnmarshallingJSON(&result),
  1674  		autorest.ByClosing())
  1675  	result.Response = autorest.Response{Response: resp}
  1676  	return
  1677  }
  1678  

View as plain text