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

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

View as plain text