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

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

View as plain text