text:
using System;
using System.Threading;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Core.Pipeline;
using Azure.ResourceManager.CosmosDB.Models;

namespace Azure.ResourceManager.CosmosDB
{
    /// <summary> The DatabaseAccounts service client. </summary>
    public partial class DatabaseAccountsOperations
    {
        private readonly ClientDiagnostics _clientDiagnostics;
        private readonly HttpPipeline _pipeline;
        internal DatabaseAccountsRestOperations RestClient { get; }

        /// <summary> Initializes a new instance of DatabaseAccountsOperations for mocking. </summary>
        protected DatabaseAccountsOperations()
        {
        }

        /// <summary> Initializes a new instance of DatabaseAccountsOperations. </summary>
        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
        /// <param name="subscriptionId"> The ID of the target subscription. </param>
        /// <param name="endpoint"> server parameter. </param>
        internal DatabaseAccountsOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string subscriptionId, Uri endpoint = null)
        {
            RestClient = new DatabaseAccountsRestOperations(clientDiagnostics, pipeline, subscriptionId, endpoint);
            _clientDiagnostics = clientDiagnostics;
            _pipeline = pipeline;
        }

        /// <summary> Retrieves the properties of an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<DatabaseAccountGetResults>> GetAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.Get");
            scope.Start();
            try
            {
                return await RestClient.GetAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Retrieves the properties of an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<DatabaseAccountGetResults> Get(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.Get");
            scope.Start();
            try
            {
                return RestClient.Get(resourceGroupName, accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<DatabaseAccountListKeysResult>> ListKeysAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListKeys");
            scope.Start();
            try
            {
                return await RestClient.ListKeysAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<DatabaseAccountListKeysResult> ListKeys(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListKeys");
            scope.Start();
            try
            {
                return RestClient.ListKeys(resourceGroupName, accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the connection strings for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<DatabaseAccountListConnectionStringsResult>> ListConnectionStringsAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListConnectionStrings");
            scope.Start();
            try
            {
                return await RestClient.ListConnectionStringsAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the connection strings for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<DatabaseAccountListConnectionStringsResult> ListConnectionStrings(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListConnectionStrings");
            scope.Start();
            try
            {
                return RestClient.ListConnectionStrings(resourceGroupName, accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the read-only access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<DatabaseAccountListReadOnlyKeysResult>> GetReadOnlyKeysAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.GetReadOnlyKeys");
            scope.Start();
            try
            {
                return await RestClient.GetReadOnlyKeysAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the read-only access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<DatabaseAccountListReadOnlyKeysResult> GetReadOnlyKeys(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.GetReadOnlyKeys");
            scope.Start();
            try
            {
                return RestClient.GetReadOnlyKeys(resourceGroupName, accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the read-only access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<DatabaseAccountListReadOnlyKeysResult>> ListReadOnlyKeysAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListReadOnlyKeys");
            scope.Start();
            try
            {
                return await RestClient.ListReadOnlyKeysAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists the read-only access keys for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<DatabaseAccountListReadOnlyKeysResult> ListReadOnlyKeys(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListReadOnlyKeys");
            scope.Start();
            try
            {
                return RestClient.ListReadOnlyKeys(resourceGroupName, accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Checks that the Azure Cosmos DB account name already exists. A valid account name may contain only lowercase letters, numbers, and the '-' character, and must be between 3 and 50 characters. </summary>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual async Task<Response<bool>> CheckNameExistsAsync(string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.CheckNameExists");
            scope.Start();
            try
            {
                return await RestClient.CheckNameExistsAsync(accountName, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Checks that the Azure Cosmos DB account name already exists. A valid account name may contain only lowercase letters, numbers, and the '-' character, and must be between 3 and 50 characters. </summary>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Response<bool> CheckNameExists(string accountName, CancellationToken cancellationToken = default)
        {
            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.CheckNameExists");
            scope.Start();
            try
            {
                return RestClient.CheckNameExists(accountName, cancellationToken);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Lists all the Azure Cosmos DB database accounts available under the subscription. </summary>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual AsyncPageable<DatabaseAccountGetResults> ListAsync(CancellationToken cancellationToken = default)
        {
            async Task<Page<DatabaseAccountGetResults>> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.List");
                scope.Start();
                try
                {
                    var response = await RestClient.ListAsync(cancellationToken).ConfigureAwait(false);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, null);
        }

        /// <summary> Lists all the Azure Cosmos DB database accounts available under the subscription. </summary>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        public virtual Pageable<DatabaseAccountGetResults> List(CancellationToken cancellationToken = default)
        {
            Page<DatabaseAccountGetResults> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.List");
                scope.Start();
                try
                {
                    var response = RestClient.List(cancellationToken);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateEnumerable(FirstPageFunc, null);
        }

        /// <summary> Lists all the Azure Cosmos DB database accounts available under the given resource group. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> is null. </exception>
        public virtual AsyncPageable<DatabaseAccountGetResults> ListByResourceGroupAsync(string resourceGroupName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }

            async Task<Page<DatabaseAccountGetResults>> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListByResourceGroup");
                scope.Start();
                try
                {
                    var response = await RestClient.ListByResourceGroupAsync(resourceGroupName, cancellationToken).ConfigureAwait(false);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, null);
        }

        /// <summary> Lists all the Azure Cosmos DB database accounts available under the given resource group. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> is null. </exception>
        public virtual Pageable<DatabaseAccountGetResults> ListByResourceGroup(string resourceGroupName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }

            Page<DatabaseAccountGetResults> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListByResourceGroup");
                scope.Start();
                try
                {
                    var response = RestClient.ListByResourceGroup(resourceGroupName, cancellationToken);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves the metrics determined by the given filter for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="filter"> An OData filter expression that describes a subset of metrics to return. The parameters that can be filtered are name.value (name of the metric, can have an or of multiple names), startTime, endTime, and timeGrain. The supported operator is eq. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="filter"/> is null. </exception>
        public virtual AsyncPageable<Metric> ListMetricsAsync(string resourceGroupName, string accountName, string filter, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            async Task<Page<Metric>> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListMetrics");
                scope.Start();
                try
                {
                    var response = await RestClient.ListMetricsAsync(resourceGroupName, accountName, filter, cancellationToken).ConfigureAwait(false);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves the metrics determined by the given filter for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="filter"> An OData filter expression that describes a subset of metrics to return. The parameters that can be filtered are name.value (name of the metric, can have an or of multiple names), startTime, endTime, and timeGrain. The supported operator is eq. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="filter"/> is null. </exception>
        public virtual Pageable<Metric> ListMetrics(string resourceGroupName, string accountName, string filter, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            Page<Metric> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListMetrics");
                scope.Start();
                try
                {
                    var response = RestClient.ListMetrics(resourceGroupName, accountName, filter, cancellationToken);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves the usages (most recent data) for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="filter"> An OData filter expression that describes a subset of usages to return. The supported parameter is name.value (name of the metric, can have an or of multiple names). </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual AsyncPageable<Usage> ListUsagesAsync(string resourceGroupName, string accountName, string filter = null, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            async Task<Page<Usage>> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListUsages");
                scope.Start();
                try
                {
                    var response = await RestClient.ListUsagesAsync(resourceGroupName, accountName, filter, cancellationToken).ConfigureAwait(false);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves the usages (most recent data) for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="filter"> An OData filter expression that describes a subset of usages to return. The supported parameter is name.value (name of the metric, can have an or of multiple names). </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual Pageable<Usage> ListUsages(string resourceGroupName, string accountName, string filter = null, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            Page<Usage> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListUsages");
                scope.Start();
                try
                {
                    var response = RestClient.ListUsages(resourceGroupName, accountName, filter, cancellationToken);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves metric definitions for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual AsyncPageable<MetricDefinition> ListMetricDefinitionsAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            async Task<Page<MetricDefinition>> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListMetricDefinitions");
                scope.Start();
                try
                {
                    var response = await RestClient.ListMetricDefinitionsAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, null);
        }

        /// <summary> Retrieves metric definitions for the given database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual Pageable<MetricDefinition> ListMetricDefinitions(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            Page<MetricDefinition> FirstPageFunc(int? pageSizeHint)
            {
                using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.ListMetricDefinitions");
                scope.Start();
                try
                {
                    var response = RestClient.ListMetricDefinitions(resourceGroupName, accountName, cancellationToken);
                    return Page.FromValues(response.Value.Value, null, response.GetRawResponse());
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }
            return PageableHelpers.CreateEnumerable(FirstPageFunc, null);
        }

        /// <summary> Updates the properties of an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="updateParameters"> The parameters to provide for the current database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="updateParameters"/> is null. </exception>
        public virtual async Task<DatabaseAccountsUpdateOperation> StartUpdateAsync(string resourceGroupName, string accountName, DatabaseAccountUpdateParameters updateParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (updateParameters == null)
            {
                throw new ArgumentNullException(nameof(updateParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartUpdate");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.UpdateAsync(resourceGroupName, accountName, updateParameters, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGroupName, accountName, updateParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Updates the properties of an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="updateParameters"> The parameters to provide for the current database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="updateParameters"/> is null. </exception>
        public virtual DatabaseAccountsUpdateOperation StartUpdate(string resourceGroupName, string accountName, DatabaseAccountUpdateParameters updateParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (updateParameters == null)
            {
                throw new ArgumentNullException(nameof(updateParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartUpdate");
            scope.Start();
            try
            {
                var originalResponse = RestClient.Update(resourceGroupName, accountName, updateParameters, cancellationToken);
                return new DatabaseAccountsUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGroupName, accountName, updateParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="createUpdateParameters"> The parameters to provide for the current database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="createUpdateParameters"/> is null. </exception>
        public virtual async Task<DatabaseAccountsCreateOrUpdateOperation> StartCreateOrUpdateAsync(string resourceGroupName, string accountName, DatabaseAccountCreateUpdateParameters createUpdateParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (createUpdateParameters == null)
            {
                throw new ArgumentNullException(nameof(createUpdateParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartCreateOrUpdate");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.CreateOrUpdateAsync(resourceGroupName, accountName, createUpdateParameters, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, accountName, createUpdateParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="createUpdateParameters"> The parameters to provide for the current database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="createUpdateParameters"/> is null. </exception>
        public virtual DatabaseAccountsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string accountName, DatabaseAccountCreateUpdateParameters createUpdateParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (createUpdateParameters == null)
            {
                throw new ArgumentNullException(nameof(createUpdateParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartCreateOrUpdate");
            scope.Start();
            try
            {
                var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, accountName, createUpdateParameters, cancellationToken);
                return new DatabaseAccountsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, accountName, createUpdateParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Deletes an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual async Task<DatabaseAccountsDeleteOperation> StartDeleteAsync(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartDelete");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.DeleteAsync(resourceGroupName, accountName, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(resourceGroupName, accountName).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Deletes an existing Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/> or <paramref name="accountName"/> is null. </exception>
        public virtual DatabaseAccountsDeleteOperation StartDelete(string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartDelete");
            scope.Start();
            try
            {
                var originalResponse = RestClient.Delete(resourceGroupName, accountName, cancellationToken);
                return new DatabaseAccountsDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(resourceGroupName, accountName).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Changes the failover priority for the Azure Cosmos DB database account. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="failoverParameters"> The new failover policies for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="failoverParameters"/> is null. </exception>
        public virtual async Task<DatabaseAccountsFailoverPriorityChangeOperation> StartFailoverPriorityChangeAsync(string resourceGroupName, string accountName, FailoverPolicies failoverParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (failoverParameters == null)
            {
                throw new ArgumentNullException(nameof(failoverParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartFailoverPriorityChange");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.FailoverPriorityChangeAsync(resourceGroupName, accountName, failoverParameters, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsFailoverPriorityChangeOperation(_clientDiagnostics, _pipeline, RestClient.CreateFailoverPriorityChangeRequest(resourceGroupName, accountName, failoverParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Changes the failover priority for the Azure Cosmos DB database account. A failover priority of 0 indicates a write region. The maximum value for a failover priority = (total number of regions - 1). Failover priority values must be unique for each of the regions in which the database account exists. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="failoverParameters"> The new failover policies for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="failoverParameters"/> is null. </exception>
        public virtual DatabaseAccountsFailoverPriorityChangeOperation StartFailoverPriorityChange(string resourceGroupName, string accountName, FailoverPolicies failoverParameters, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (failoverParameters == null)
            {
                throw new ArgumentNullException(nameof(failoverParameters));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartFailoverPriorityChange");
            scope.Start();
            try
            {
                var originalResponse = RestClient.FailoverPriorityChange(resourceGroupName, accountName, failoverParameters, cancellationToken);
                return new DatabaseAccountsFailoverPriorityChangeOperation(_clientDiagnostics, _pipeline, RestClient.CreateFailoverPriorityChangeRequest(resourceGroupName, accountName, failoverParameters).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Offline the specified region for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="regionParameterForOffline"> Cosmos DB region to offline for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="regionParameterForOffline"/> is null. </exception>
        public virtual async Task<DatabaseAccountsOfflineRegionOperation> StartOfflineRegionAsync(string resourceGroupName, string accountName, RegionForOnlineOffline regionParameterForOffline, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (regionParameterForOffline == null)
            {
                throw new ArgumentNullException(nameof(regionParameterForOffline));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartOfflineRegion");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.OfflineRegionAsync(resourceGroupName, accountName, regionParameterForOffline, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsOfflineRegionOperation(_clientDiagnostics, _pipeline, RestClient.CreateOfflineRegionRequest(resourceGroupName, accountName, regionParameterForOffline).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Offline the specified region for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="regionParameterForOffline"> Cosmos DB region to offline for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="regionParameterForOffline"/> is null. </exception>
        public virtual DatabaseAccountsOfflineRegionOperation StartOfflineRegion(string resourceGroupName, string accountName, RegionForOnlineOffline regionParameterForOffline, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (regionParameterForOffline == null)
            {
                throw new ArgumentNullException(nameof(regionParameterForOffline));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartOfflineRegion");
            scope.Start();
            try
            {
                var originalResponse = RestClient.OfflineRegion(resourceGroupName, accountName, regionParameterForOffline, cancellationToken);
                return new DatabaseAccountsOfflineRegionOperation(_clientDiagnostics, _pipeline, RestClient.CreateOfflineRegionRequest(resourceGroupName, accountName, regionParameterForOffline).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Online the specified region for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="regionParameterForOnline"> Cosmos DB region to online for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="regionParameterForOnline"/> is null. </exception>
        public virtual async Task<DatabaseAccountsOnlineRegionOperation> StartOnlineRegionAsync(string resourceGroupName, string accountName, RegionForOnlineOffline regionParameterForOnline, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (regionParameterForOnline == null)
            {
                throw new ArgumentNullException(nameof(regionParameterForOnline));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartOnlineRegion");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.OnlineRegionAsync(resourceGroupName, accountName, regionParameterForOnline, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsOnlineRegionOperation(_clientDiagnostics, _pipeline, RestClient.CreateOnlineRegionRequest(resourceGroupName, accountName, regionParameterForOnline).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Online the specified region for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="regionParameterForOnline"> Cosmos DB region to online for the database account. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="regionParameterForOnline"/> is null. </exception>
        public virtual DatabaseAccountsOnlineRegionOperation StartOnlineRegion(string resourceGroupName, string accountName, RegionForOnlineOffline regionParameterForOnline, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (regionParameterForOnline == null)
            {
                throw new ArgumentNullException(nameof(regionParameterForOnline));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartOnlineRegion");
            scope.Start();
            try
            {
                var originalResponse = RestClient.OnlineRegion(resourceGroupName, accountName, regionParameterForOnline, cancellationToken);
                return new DatabaseAccountsOnlineRegionOperation(_clientDiagnostics, _pipeline, RestClient.CreateOnlineRegionRequest(resourceGroupName, accountName, regionParameterForOnline).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Regenerates an access key for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="keyToRegenerate"> The name of the key to regenerate. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="keyToRegenerate"/> is null. </exception>
        public virtual async Task<DatabaseAccountsRegenerateKeyOperation> StartRegenerateKeyAsync(string resourceGroupName, string accountName, DatabaseAccountRegenerateKeyParameters keyToRegenerate, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (keyToRegenerate == null)
            {
                throw new ArgumentNullException(nameof(keyToRegenerate));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartRegenerateKey");
            scope.Start();
            try
            {
                var originalResponse = await RestClient.RegenerateKeyAsync(resourceGroupName, accountName, keyToRegenerate, cancellationToken).ConfigureAwait(false);
                return new DatabaseAccountsRegenerateKeyOperation(_clientDiagnostics, _pipeline, RestClient.CreateRegenerateKeyRequest(resourceGroupName, accountName, keyToRegenerate).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }

        /// <summary> Regenerates an access key for the specified Azure Cosmos DB database account. </summary>
        /// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
        /// <param name="accountName"> Cosmos DB database account name. </param>
        /// <param name="keyToRegenerate"> The name of the key to regenerate. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupName"/>, <paramref name="accountName"/>, or <paramref name="keyToRegenerate"/> is null. </exception>
        public virtual DatabaseAccountsRegenerateKeyOperation StartRegenerateKey(string resourceGroupName, string accountName, DatabaseAccountRegenerateKeyParameters keyToRegenerate, CancellationToken cancellationToken = default)
        {
            if (resourceGroupName == null)
            {
                throw new ArgumentNullException(nameof(resourceGroupName));
            }
            if (accountName == null)
            {
                throw new ArgumentNullException(nameof(accountName));
            }
            if (keyToRegenerate == null)
            {
                throw new ArgumentNullException(nameof(keyToRegenerate));
            }

            using var scope = _clientDiagnostics.CreateScope("DatabaseAccountsOperations.StartRegenerateKey");
            scope.Start();
            try
            {
                var originalResponse = RestClient.RegenerateKey(resourceGroupName, accountName, keyToRegenerate, cancellationToken);
                return new DatabaseAccountsRegenerateKeyOperation(_clientDiagnostics, _pipeline, RestClient.CreateRegenerateKeyRequest(resourceGroupName, accountName, keyToRegenerate).Request, originalResponse);
            }
            catch (Exception e)
            {
                scope.Failed(e);
                throw;
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


Handcrafted by silversmiths in Galicia, northern Spain, this beautiful sterling-silver scallop shell / concha de vieira is the symbol of the Camino de Santiago.
The 1,000-year-old Way of St. James (El Camino de Santiago - in Spanish), criss-crosses Western Europe, arriving at Santiago de Compostela in Northern Spain on the Atlantic coast. At least 200,000 people travel the Camino each year from all over the world: Some people walk, others travel by bike. Many travellers choose to do the Camino for personal, rather than any spiritual or religious reasons - taking time out from their busy/modern lives and perhaps finding inspiration along the way, whilst reflecting on their life in a supportive environment. Many carry with them a Scallop Shell like this. Everyone experiences the journey in a different way.
Wish your friends or loved-ones well by sending this inspirational present. It is an ideal gift to show someone that you really care. Hand-crafted in the silver workshops of Galicia, northern Spain.
Dimensions: Shell measures 25mm in length including the hanging ring and comes with an 18ins sterling silver snake chain. (20ins length also available). Please choose in options box.
But, whatever somebody's journey - whether on El Camino itself, on holiday, a business trip, a gap year, trekking, etc, many friends and loved-ones like to pass on a special gift to wish the recipient well on their travels - and safekeeping along the way. This necklace is perfect for that purpose. In addition to any value that the Camino charm symbol has in itself, or the religious faith that it might represent, this necklace can also act as a reminder to be careful when travelling. And this can be a powerful aid to staying safe whilst away from home.
Gift this scallop shell necklace (believed to encourage strength and hope) to inspire your friends or family, and perhaps help them in their lives. Comes gift-wrapped, like all our presents - and we can print a personal message on your behalf.


text:
Q: Using the Method of Characteristics to Determine Invariant Solutions The PDE I want to solve, by finding invariants and reducing order is:
$$
u_t-uu_x-u_{xxx}=0
$$

*

*One solution is found as follows:

1. Solve $\frac{du}{1}=\frac{dx}{t}$
Since we don't have a $dt$ term, we set the first invariant as $y=t$
I solve:
\begin{align}
\frac{du}{1}&=\frac{dx}{-t}\\
u  &= \frac{-1}{t}x + C\\
\end{align}
The second invariant is given as $v =tu + x$ which can be rewritten as : $u = \frac{1}{t}v - \frac{1}{t}x$
2. Now determine $u_x, u_{xxx}, u_t$ in terms of $\frac{dv}{dy}$
\begin{align}
u_x &= \frac{-1}{t}\\
&= \frac{-1}{y}\\
u_{xxx} &= 0\\
u_t &= \frac{1}{y^2}(yv_y-v+x)\\
\end{align}
3. Sub $u_{xxx}, u_x, u_t$ into the original ODE
\begin{align}
\frac{1}{y^2}(yv_y-v+x) + \frac{1}{y^2}(v-x)-0&=0\\
yv_y - v + x + v - x &= 0\\
y\frac{dv}{dy} &=0\\
v &= \alpha \\
\end{align}
So the solution we get is $u = \frac{\alpha - x}{t}$
I now want to repeat the process, but now I want to solve:
$$
\frac{i\omega dx}{\sin(i\omega x)} = \frac{\omega^2dt}{3t\cos(i\omega x)} = \frac{-i\omega du}{2\sin(i \omega u)}
$$
I solve:
\begin{align}
\frac{i \omega dx}{\sin(i \omega x)}&=\frac{\omega^2 dt}{3t\cos(i \omega x)}\\
\frac{3i}{\omega}\cot(i \omega x)dx&=\frac{1}{t}dt\\
\frac{3\ln(\sinh(\omega x))}{\omega^2} &= \ln t + \ln C\\
\ln (\sinh(\omega x)^{\frac{3}{\omega^2}} - \ln T &= \ln C\\
\end{align}
So the first invariant is:
$$
r = \frac{\sinh(\omega x)^{\frac{3}{\omega ^2}}}{t}
$$
Now I solve:
\begin{align}
\frac{i \omega dx}{\sin(i \omega x)} &= \frac{-i \omega du}{2 \sin(i \omega u)}\\
\frac{-2dx}{\sin(i \omega x)} &= \frac{du}{\sin (i \omega u)}\\
\frac{-2i\ln(\operatorname{csch}(\omega x) + \coth( \omega x))}{w} +\ln C &= \frac{i\ln(\operatorname{csch}(\omega u) + \coth(\omega u))}{w}\\
\end{align}
How can I isolate my constant and get the next invariant?

redpajama_set_name: RedPajamaStackExchange


W7 Cosmetics is a UK based cosmetics company. Their aim - that every woman should have access to an extensive range of high-quality cosmetics at an affordable price, so you never have to struggle between deciding to spend your money on food or makeup again.
Too broke to spend another $50 on an eyeshadow palette that you will probably never hit pan on? I feel you. Get on trend with the rusty red eye look with a mix of matte and shimmer shades, perfect for transitioning and defining at just $19.90!
Rose gold and bronze shades… need I say more? A perfect for starters who are on the hunt for a pigmented eyeshadow palette that is easily blendable.
There's nothing like starting your makeup with a clean canvas. Lack of sleep? Dull skin? This peach primer targets skin that needs a punch of radiance for a fresh finish!
If the saying of "the wings of your eyeliner should be sharp enough to kill", this is probably the only weapon you would need to achieve that.
Some say this is a dupe for the Benefit They're Real! Mascara. Nuff' said, google it and try it for yourself!
The popular Glowcomotion range comes in a subtle golden glow that can be used as a highlighter, shimmer or even an eyeshadow. One product with 3 uses? We're taking it!
Don't forget to set in this humid weather! Achieve the airbrush finish or bake under your eyes for ultra skin brightening.
Last step - lock it all in! One of the bestsellers from the W7 Cosmetics range. Perfect travel size to carry on the go for a quick refreshing mist!
Above are just a few of the many products that W7 Cosmetics offer. You may shop the entire range online at http://bitly.com/shopw7cosmetics.
BONUS: GET 30% OFF YOUR W7 PRODUCTS! Key in "W7UK" upon checkout. No minimum purchase required. Promotion valid till 31 Aug 2018 2359 only!