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

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

View as plain text