text:
#pragma once
#include <aws/dax/DAX_EXPORTS.h>
#include <aws/dax/DAXErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/dax/model/CreateClusterResult.h>
#include <aws/dax/model/CreateParameterGroupResult.h>
#include <aws/dax/model/CreateSubnetGroupResult.h>
#include <aws/dax/model/DecreaseReplicationFactorResult.h>
#include <aws/dax/model/DeleteClusterResult.h>
#include <aws/dax/model/DeleteParameterGroupResult.h>
#include <aws/dax/model/DeleteSubnetGroupResult.h>
#include <aws/dax/model/DescribeClustersResult.h>
#include <aws/dax/model/DescribeDefaultParametersResult.h>
#include <aws/dax/model/DescribeEventsResult.h>
#include <aws/dax/model/DescribeParameterGroupsResult.h>
#include <aws/dax/model/DescribeParametersResult.h>
#include <aws/dax/model/DescribeSubnetGroupsResult.h>
#include <aws/dax/model/IncreaseReplicationFactorResult.h>
#include <aws/dax/model/ListTagsResult.h>
#include <aws/dax/model/RebootNodeResult.h>
#include <aws/dax/model/TagResourceResult.h>
#include <aws/dax/model/UntagResourceResult.h>
#include <aws/dax/model/UpdateClusterResult.h>
#include <aws/dax/model/UpdateParameterGroupResult.h>
#include <aws/dax/model/UpdateSubnetGroupResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

namespace Aws
{

namespace Http
{
  class HttpClient;
  class HttpClientFactory;
} // namespace Http

namespace Utils
{
  template< typename R, typename E> class Outcome;

namespace Threading
{
  class Executor;
} // namespace Threading
} // namespace Utils

namespace Auth
{
  class AWSCredentials;
  class AWSCredentialsProvider;
} // namespace Auth

namespace Client
{
  class RetryStrategy;
} // namespace Client

namespace DAX
{

namespace Model
{
        class CreateClusterRequest;
        class CreateParameterGroupRequest;
        class CreateSubnetGroupRequest;
        class DecreaseReplicationFactorRequest;
        class DeleteClusterRequest;
        class DeleteParameterGroupRequest;
        class DeleteSubnetGroupRequest;
        class DescribeClustersRequest;
        class DescribeDefaultParametersRequest;
        class DescribeEventsRequest;
        class DescribeParameterGroupsRequest;
        class DescribeParametersRequest;
        class DescribeSubnetGroupsRequest;
        class IncreaseReplicationFactorRequest;
        class ListTagsRequest;
        class RebootNodeRequest;
        class TagResourceRequest;
        class UntagResourceRequest;
        class UpdateClusterRequest;
        class UpdateParameterGroupRequest;
        class UpdateSubnetGroupRequest;

        typedef Aws::Utils::Outcome<CreateClusterResult, Aws::Client::AWSError<DAXErrors>> CreateClusterOutcome;
        typedef Aws::Utils::Outcome<CreateParameterGroupResult, Aws::Client::AWSError<DAXErrors>> CreateParameterGroupOutcome;
        typedef Aws::Utils::Outcome<CreateSubnetGroupResult, Aws::Client::AWSError<DAXErrors>> CreateSubnetGroupOutcome;
        typedef Aws::Utils::Outcome<DecreaseReplicationFactorResult, Aws::Client::AWSError<DAXErrors>> DecreaseReplicationFactorOutcome;
        typedef Aws::Utils::Outcome<DeleteClusterResult, Aws::Client::AWSError<DAXErrors>> DeleteClusterOutcome;
        typedef Aws::Utils::Outcome<DeleteParameterGroupResult, Aws::Client::AWSError<DAXErrors>> DeleteParameterGroupOutcome;
        typedef Aws::Utils::Outcome<DeleteSubnetGroupResult, Aws::Client::AWSError<DAXErrors>> DeleteSubnetGroupOutcome;
        typedef Aws::Utils::Outcome<DescribeClustersResult, Aws::Client::AWSError<DAXErrors>> DescribeClustersOutcome;
        typedef Aws::Utils::Outcome<DescribeDefaultParametersResult, Aws::Client::AWSError<DAXErrors>> DescribeDefaultParametersOutcome;
        typedef Aws::Utils::Outcome<DescribeEventsResult, Aws::Client::AWSError<DAXErrors>> DescribeEventsOutcome;
        typedef Aws::Utils::Outcome<DescribeParameterGroupsResult, Aws::Client::AWSError<DAXErrors>> DescribeParameterGroupsOutcome;
        typedef Aws::Utils::Outcome<DescribeParametersResult, Aws::Client::AWSError<DAXErrors>> DescribeParametersOutcome;
        typedef Aws::Utils::Outcome<DescribeSubnetGroupsResult, Aws::Client::AWSError<DAXErrors>> DescribeSubnetGroupsOutcome;
        typedef Aws::Utils::Outcome<IncreaseReplicationFactorResult, Aws::Client::AWSError<DAXErrors>> IncreaseReplicationFactorOutcome;
        typedef Aws::Utils::Outcome<ListTagsResult, Aws::Client::AWSError<DAXErrors>> ListTagsOutcome;
        typedef Aws::Utils::Outcome<RebootNodeResult, Aws::Client::AWSError<DAXErrors>> RebootNodeOutcome;
        typedef Aws::Utils::Outcome<TagResourceResult, Aws::Client::AWSError<DAXErrors>> TagResourceOutcome;
        typedef Aws::Utils::Outcome<UntagResourceResult, Aws::Client::AWSError<DAXErrors>> UntagResourceOutcome;
        typedef Aws::Utils::Outcome<UpdateClusterResult, Aws::Client::AWSError<DAXErrors>> UpdateClusterOutcome;
        typedef Aws::Utils::Outcome<UpdateParameterGroupResult, Aws::Client::AWSError<DAXErrors>> UpdateParameterGroupOutcome;
        typedef Aws::Utils::Outcome<UpdateSubnetGroupResult, Aws::Client::AWSError<DAXErrors>> UpdateSubnetGroupOutcome;

        typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
        typedef std::future<CreateParameterGroupOutcome> CreateParameterGroupOutcomeCallable;
        typedef std::future<CreateSubnetGroupOutcome> CreateSubnetGroupOutcomeCallable;
        typedef std::future<DecreaseReplicationFactorOutcome> DecreaseReplicationFactorOutcomeCallable;
        typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;
        typedef std::future<DeleteParameterGroupOutcome> DeleteParameterGroupOutcomeCallable;
        typedef std::future<DeleteSubnetGroupOutcome> DeleteSubnetGroupOutcomeCallable;
        typedef std::future<DescribeClustersOutcome> DescribeClustersOutcomeCallable;
        typedef std::future<DescribeDefaultParametersOutcome> DescribeDefaultParametersOutcomeCallable;
        typedef std::future<DescribeEventsOutcome> DescribeEventsOutcomeCallable;
        typedef std::future<DescribeParameterGroupsOutcome> DescribeParameterGroupsOutcomeCallable;
        typedef std::future<DescribeParametersOutcome> DescribeParametersOutcomeCallable;
        typedef std::future<DescribeSubnetGroupsOutcome> DescribeSubnetGroupsOutcomeCallable;
        typedef std::future<IncreaseReplicationFactorOutcome> IncreaseReplicationFactorOutcomeCallable;
        typedef std::future<ListTagsOutcome> ListTagsOutcomeCallable;
        typedef std::future<RebootNodeOutcome> RebootNodeOutcomeCallable;
        typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
        typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
        typedef std::future<UpdateClusterOutcome> UpdateClusterOutcomeCallable;
        typedef std::future<UpdateParameterGroupOutcome> UpdateParameterGroupOutcomeCallable;
        typedef std::future<UpdateSubnetGroupOutcome> UpdateSubnetGroupOutcomeCallable;
} // namespace Model

  class DAXClient;

    typedef std::function<void(const DAXClient*, const Model::CreateClusterRequest&, const Model::CreateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateClusterResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::CreateParameterGroupRequest&, const Model::CreateParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateParameterGroupResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::CreateSubnetGroupRequest&, const Model::CreateSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateSubnetGroupResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DecreaseReplicationFactorRequest&, const Model::DecreaseReplicationFactorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DecreaseReplicationFactorResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DeleteClusterRequest&, const Model::DeleteClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteClusterResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DeleteParameterGroupRequest&, const Model::DeleteParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteParameterGroupResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DeleteSubnetGroupRequest&, const Model::DeleteSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteSubnetGroupResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeClustersRequest&, const Model::DescribeClustersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeClustersResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeDefaultParametersRequest&, const Model::DescribeDefaultParametersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeDefaultParametersResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeEventsRequest&, const Model::DescribeEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventsResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeParameterGroupsRequest&, const Model::DescribeParameterGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeParameterGroupsResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeParametersRequest&, const Model::DescribeParametersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeParametersResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::DescribeSubnetGroupsRequest&, const Model::DescribeSubnetGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeSubnetGroupsResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::IncreaseReplicationFactorRequest&, const Model::IncreaseReplicationFactorOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > IncreaseReplicationFactorResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::ListTagsRequest&, const Model::ListTagsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::RebootNodeRequest&, const Model::RebootNodeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RebootNodeResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::UpdateClusterRequest&, const Model::UpdateClusterOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateClusterResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::UpdateParameterGroupRequest&, const Model::UpdateParameterGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateParameterGroupResponseReceivedHandler;
    typedef std::function<void(const DAXClient*, const Model::UpdateSubnetGroupRequest&, const Model::UpdateSubnetGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateSubnetGroupResponseReceivedHandler;

  /**
   *
DAX is a managed caching service engineered for Amazon DynamoDB. DAX
   * dramatically speeds up database reads by caching frequently-accessed data from
   * DynamoDB, so applications can access that data with sub-millisecond latency. You
   * can create a DAX cluster easily, using the AWS Management Console. With a few
   * simple modifications to your code, your application can begin taking advantage
   * of the DAX cluster and realize significant improvements in read performance.

   */
  class AWS_DAX_API DAXClient : public Aws::Client::AWSJsonClient
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;

       /**
        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        DAXClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        DAXClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
        * the default http client factory will be used
        */
        DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

        virtual ~DAXClient();

        inline virtual const char* GetServiceClientName() const override { return "DAX"; }

        /**
         *
Creates a DAX cluster. All nodes in the cluster run the same DAX caching
         * software.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;

        /**
         *
Creates a DAX cluster. All nodes in the cluster run the same DAX caching
         * software.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateClusterOutcomeCallable CreateClusterCallable(const Model::CreateClusterRequest& request) const;

        /**
         *
Creates a DAX cluster. All nodes in the cluster run the same DAX caching
         * software.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a new parameter group. A parameter group is a collection of
         * parameters that you apply to all of the nodes in a DAX cluster.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::CreateParameterGroupOutcome CreateParameterGroup(const Model::CreateParameterGroupRequest& request) const;

        /**
         *
Creates a new parameter group. A parameter group is a collection of
         * parameters that you apply to all of the nodes in a DAX cluster.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateParameterGroupOutcomeCallable CreateParameterGroupCallable(const Model::CreateParameterGroupRequest& request) const;

        /**
         *
Creates a new parameter group. A parameter group is a collection of
         * parameters that you apply to all of the nodes in a DAX cluster.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateParameterGroupAsync(const Model::CreateParameterGroupRequest& request, const CreateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Creates a new subnet group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::CreateSubnetGroupOutcome CreateSubnetGroup(const Model::CreateSubnetGroupRequest& request) const;

        /**
         *
Creates a new subnet group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::CreateSubnetGroupOutcomeCallable CreateSubnetGroupCallable(const Model::CreateSubnetGroupRequest& request) const;

        /**
         *
Creates a new subnet group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void CreateSubnetGroupAsync(const Model::CreateSubnetGroupRequest& request, const CreateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Removes one or more nodes from a DAX cluster.
 <note>
You cannot use
         * DecreaseReplicationFactor to remove the last node in a DAX cluster.
         * If you need to do this, use DeleteCluster instead.

         * </note>

See Also:
   AWS
         * API Reference

         */
        virtual Model::DecreaseReplicationFactorOutcome DecreaseReplicationFactor(const Model::DecreaseReplicationFactorRequest& request) const;

        /**
         *
Removes one or more nodes from a DAX cluster.
 <note>
You cannot use
         * DecreaseReplicationFactor to remove the last node in a DAX cluster.
         * If you need to do this, use DeleteCluster instead.

         * </note>

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DecreaseReplicationFactorOutcomeCallable DecreaseReplicationFactorCallable(const Model::DecreaseReplicationFactorRequest& request) const;

        /**
         *
Removes one or more nodes from a DAX cluster.
 <note>
You cannot use
         * DecreaseReplicationFactor to remove the last node in a DAX cluster.
         * If you need to do this, use DeleteCluster instead.

         * </note>

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DecreaseReplicationFactorAsync(const Model::DecreaseReplicationFactorRequest& request, const DecreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a previously provisioned DAX cluster. DeleteCluster deletes
         * all associated nodes, node endpoints and the DAX cluster itself. When you
         * receive a successful response from this action, DAX immediately begins deleting
         * the cluster; you cannot cancel or revert this action.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;

        /**
         *
Deletes a previously provisioned DAX cluster. DeleteCluster deletes
         * all associated nodes, node endpoints and the DAX cluster itself. When you
         * receive a successful response from this action, DAX immediately begins deleting
         * the cluster; you cannot cancel or revert this action.

See Also:

         * AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const Model::DeleteClusterRequest& request) const;

        /**
         *
Deletes a previously provisioned DAX cluster. DeleteCluster deletes
         * all associated nodes, node endpoints and the DAX cluster itself. When you
         * receive a successful response from this action, DAX immediately begins deleting
         * the cluster; you cannot cancel or revert this action.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes the specified parameter group. You cannot delete a parameter group if
         * it is associated with any DAX clusters.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteParameterGroupOutcome DeleteParameterGroup(const Model::DeleteParameterGroupRequest& request) const;

        /**
         *
Deletes the specified parameter group. You cannot delete a parameter group if
         * it is associated with any DAX clusters.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteParameterGroupOutcomeCallable DeleteParameterGroupCallable(const Model::DeleteParameterGroupRequest& request) const;

        /**
         *
Deletes the specified parameter group. You cannot delete a parameter group if
         * it is associated with any DAX clusters.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteParameterGroupAsync(const Model::DeleteParameterGroupRequest& request, const DeleteParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Deletes a subnet group.
 <note>
You cannot delete a subnet group if it
         * is associated with any DAX clusters.
 </note>

See Also:
   AWS
         * API Reference

         */
        virtual Model::DeleteSubnetGroupOutcome DeleteSubnetGroup(const Model::DeleteSubnetGroupRequest& request) const;

        /**
         *
Deletes a subnet group.
 <note>
You cannot delete a subnet group if it
         * is associated with any DAX clusters.
 </note>

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DeleteSubnetGroupOutcomeCallable DeleteSubnetGroupCallable(const Model::DeleteSubnetGroupRequest& request) const;

        /**
         *
Deletes a subnet group.
 <note>
You cannot delete a subnet group if it
         * is associated with any DAX clusters.
 </note>

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DeleteSubnetGroupAsync(const Model::DeleteSubnetGroupRequest& request, const DeleteSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns information about all provisioned DAX clusters if no cluster
         * identifier is specified, or about a specific DAX cluster if a cluster identifier
         * is supplied.

If the cluster is in the CREATING state, only cluster level
         * information will be displayed until all of the nodes are successfully
         * provisioned.

If the cluster is in the DELETING state, only cluster level
         * information will be displayed.

If nodes are currently being added to the
         * DAX cluster, node endpoint information and creation time for the additional
         * nodes will not be displayed until they are completely provisioned. When the DAX
         * cluster state is available, the cluster is ready for use.

If nodes
         * are currently being removed from the DAX cluster, no endpoint information for
         * the removed nodes is displayed.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request) const;

        /**
         *
Returns information about all provisioned DAX clusters if no cluster
         * identifier is specified, or about a specific DAX cluster if a cluster identifier
         * is supplied.

If the cluster is in the CREATING state, only cluster level
         * information will be displayed until all of the nodes are successfully
         * provisioned.

If the cluster is in the DELETING state, only cluster level
         * information will be displayed.

If nodes are currently being added to the
         * DAX cluster, node endpoint information and creation time for the additional
         * nodes will not be displayed until they are completely provisioned. When the DAX
         * cluster state is available, the cluster is ready for use.

If nodes
         * are currently being removed from the DAX cluster, no endpoint information for
         * the removed nodes is displayed.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const Model::DescribeClustersRequest& request) const;

        /**
         *
Returns information about all provisioned DAX clusters if no cluster
         * identifier is specified, or about a specific DAX cluster if a cluster identifier
         * is supplied.

If the cluster is in the CREATING state, only cluster level
         * information will be displayed until all of the nodes are successfully
         * provisioned.

If the cluster is in the DELETING state, only cluster level
         * information will be displayed.

If nodes are currently being added to the
         * DAX cluster, node endpoint information and creation time for the additional
         * nodes will not be displayed until they are completely provisioned. When the DAX
         * cluster state is available, the cluster is ready for use.

If nodes
         * are currently being removed from the DAX cluster, no endpoint information for
         * the removed nodes is displayed.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeClustersAsync(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the default system parameter information for the DAX caching
         * software.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeDefaultParametersOutcome DescribeDefaultParameters(const Model::DescribeDefaultParametersRequest& request) const;

        /**
         *
Returns the default system parameter information for the DAX caching
         * software.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeDefaultParametersOutcomeCallable DescribeDefaultParametersCallable(const Model::DescribeDefaultParametersRequest& request) const;

        /**
         *
Returns the default system parameter information for the DAX caching
         * software.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeDefaultParametersAsync(const Model::DescribeDefaultParametersRequest& request, const DescribeDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns events related to DAX clusters and parameter groups. You can obtain
         * events specific to a particular DAX cluster or parameter group by providing the
         * name as a parameter.

By default, only the events occurring within the
         * last hour are returned; however, you can retrieve up to 14 days' worth of events
         * if necessary.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request) const;

        /**
         *
Returns events related to DAX clusters and parameter groups. You can obtain
         * events specific to a particular DAX cluster or parameter group by providing the
         * name as a parameter.

By default, only the events occurring within the
         * last hour are returned; however, you can retrieve up to 14 days' worth of events
         * if necessary.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const Model::DescribeEventsRequest& request) const;

        /**
         *
Returns events related to DAX clusters and parameter groups. You can obtain
         * events specific to a particular DAX cluster or parameter group by providing the
         * name as a parameter.

By default, only the events occurring within the
         * last hour are returned; however, you can retrieve up to 14 days' worth of events
         * if necessary.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeEventsAsync(const Model::DescribeEventsRequest& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns a list of parameter group descriptions. If a parameter group name is
         * specified, the list will contain only the descriptions for that
         * group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeParameterGroupsOutcome DescribeParameterGroups(const Model::DescribeParameterGroupsRequest& request) const;

        /**
         *
Returns a list of parameter group descriptions. If a parameter group name is
         * specified, the list will contain only the descriptions for that
         * group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeParameterGroupsOutcomeCallable DescribeParameterGroupsCallable(const Model::DescribeParameterGroupsRequest& request) const;

        /**
         *
Returns a list of parameter group descriptions. If a parameter group name is
         * specified, the list will contain only the descriptions for that
         * group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeParameterGroupsAsync(const Model::DescribeParameterGroupsRequest& request, const DescribeParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns the detailed parameter list for a particular parameter
         * group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request) const;

        /**
         *
Returns the detailed parameter list for a particular parameter
         * group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const Model::DescribeParametersRequest& request) const;

        /**
         *
Returns the detailed parameter list for a particular parameter
         * group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeParametersAsync(const Model::DescribeParametersRequest& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Returns a list of subnet group descriptions. If a subnet group name is
         * specified, the list will contain only the description of that
         * group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeSubnetGroupsOutcome DescribeSubnetGroups(const Model::DescribeSubnetGroupsRequest& request) const;

        /**
         *
Returns a list of subnet group descriptions. If a subnet group name is
         * specified, the list will contain only the description of that
         * group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeSubnetGroupsOutcomeCallable DescribeSubnetGroupsCallable(const Model::DescribeSubnetGroupsRequest& request) const;

        /**
         *
Returns a list of subnet group descriptions. If a subnet group name is
         * specified, the list will contain only the description of that
         * group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeSubnetGroupsAsync(const Model::DescribeSubnetGroupsRequest& request, const DescribeSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Adds one or more nodes to a DAX cluster.

See Also:
   AWS
         * API Reference

         */
        virtual Model::IncreaseReplicationFactorOutcome IncreaseReplicationFactor(const Model::IncreaseReplicationFactorRequest& request) const;

        /**
         *
Adds one or more nodes to a DAX cluster.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::IncreaseReplicationFactorOutcomeCallable IncreaseReplicationFactorCallable(const Model::IncreaseReplicationFactorRequest& request) const;

        /**
         *
Adds one or more nodes to a DAX cluster.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void IncreaseReplicationFactorAsync(const Model::IncreaseReplicationFactorRequest& request, const IncreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
List all of the tags for a DAX cluster. You can call ListTags up
         * to 10 times per second, per account.

See Also:
   AWS API
         * Reference

         */
        virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;

        /**
         *
List all of the tags for a DAX cluster. You can call ListTags up
         * to 10 times per second, per account.

See Also:
   AWS API
         * Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListTagsOutcomeCallable ListTagsCallable(const Model::ListTagsRequest& request) const;

        /**
         *
List all of the tags for a DAX cluster. You can call ListTags up
         * to 10 times per second, per account.

See Also:
   AWS API
         * Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListTagsAsync(const Model::ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Reboots a single node of a DAX cluster. The reboot action takes place as soon
         * as possible. During the reboot, the node status is set to
         * REBOOTING.

See Also:
   AWS API
         * Reference

         */
        virtual Model::RebootNodeOutcome RebootNode(const Model::RebootNodeRequest& request) const;

        /**
         *
Reboots a single node of a DAX cluster. The reboot action takes place as soon
         * as possible. During the reboot, the node status is set to
         * REBOOTING.

See Also:
   AWS API
         * Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::RebootNodeOutcomeCallable RebootNodeCallable(const Model::RebootNodeRequest& request) const;

        /**
         *
Reboots a single node of a DAX cluster. The reboot action takes place as soon
         * as possible. During the reboot, the node status is set to
         * REBOOTING.

See Also:
   AWS API
         * Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void RebootNodeAsync(const Model::RebootNodeRequest& request, const RebootNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Associates a set of tags with a DAX resource. You can call
         * TagResource up to 5 times per second, per account.

See
         * Also:
   AWS API
         * Reference

         */
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;

        /**
         *
Associates a set of tags with a DAX resource. You can call
         * TagResource up to 5 times per second, per account.

See
         * Also:
   AWS API
         * Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;

        /**
         *
Associates a set of tags with a DAX resource. You can call
         * TagResource up to 5 times per second, per account.

See
         * Also:
   AWS API
         * Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Removes the association of tags from a DAX resource. You can call
         * UntagResource up to 5 times per second, per account.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;

        /**
         *
Removes the association of tags from a DAX resource. You can call
         * UntagResource up to 5 times per second, per account.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;

        /**
         *
Removes the association of tags from a DAX resource. You can call
         * UntagResource up to 5 times per second, per account.

See
         * Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Modifies the settings for a DAX cluster. You can use this action to change
         * one or more cluster configuration parameters by specifying the parameters and
         * the new values.

See Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;

        /**
         *
Modifies the settings for a DAX cluster. You can use this action to change
         * one or more cluster configuration parameters by specifying the parameters and
         * the new values.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const Model::UpdateClusterRequest& request) const;

        /**
         *
Modifies the settings for a DAX cluster. You can use this action to change
         * one or more cluster configuration parameters by specifying the parameters and
         * the new values.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateClusterAsync(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Modifies the parameters of a parameter group. You can modify up to 20
         * parameters in a single request by submitting a list parameter name and value
         * pairs.

See Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateParameterGroupOutcome UpdateParameterGroup(const Model::UpdateParameterGroupRequest& request) const;

        /**
         *
Modifies the parameters of a parameter group. You can modify up to 20
         * parameters in a single request by submitting a list parameter name and value
         * pairs.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateParameterGroupOutcomeCallable UpdateParameterGroupCallable(const Model::UpdateParameterGroupRequest& request) const;

        /**
         *
Modifies the parameters of a parameter group. You can modify up to 20
         * parameters in a single request by submitting a list parameter name and value
         * pairs.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateParameterGroupAsync(const Model::UpdateParameterGroupRequest& request, const UpdateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Modifies an existing subnet group.

See Also:
   AWS
         * API Reference

         */
        virtual Model::UpdateSubnetGroupOutcome UpdateSubnetGroup(const Model::UpdateSubnetGroupRequest& request) const;

        /**
         *
Modifies an existing subnet group.

See Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::UpdateSubnetGroupOutcomeCallable UpdateSubnetGroupCallable(const Model::UpdateSubnetGroupRequest& request) const;

        /**
         *
Modifies an existing subnet group.

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void UpdateSubnetGroupAsync(const Model::UpdateSubnetGroupRequest& request, const UpdateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);

        /**Async helpers**/
        void CreateClusterAsyncHelper(const Model::CreateClusterRequest& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateParameterGroupAsyncHelper(const Model::CreateParameterGroupRequest& request, const CreateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void CreateSubnetGroupAsyncHelper(const Model::CreateSubnetGroupRequest& request, const CreateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DecreaseReplicationFactorAsyncHelper(const Model::DecreaseReplicationFactorRequest& request, const DecreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteClusterAsyncHelper(const Model::DeleteClusterRequest& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteParameterGroupAsyncHelper(const Model::DeleteParameterGroupRequest& request, const DeleteParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DeleteSubnetGroupAsyncHelper(const Model::DeleteSubnetGroupRequest& request, const DeleteSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeClustersAsyncHelper(const Model::DescribeClustersRequest& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeDefaultParametersAsyncHelper(const Model::DescribeDefaultParametersRequest& request, const DescribeDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEventsAsyncHelper(const Model::DescribeEventsRequest& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeParameterGroupsAsyncHelper(const Model::DescribeParameterGroupsRequest& request, const DescribeParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeParametersAsyncHelper(const Model::DescribeParametersRequest& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeSubnetGroupsAsyncHelper(const Model::DescribeSubnetGroupsRequest& request, const DescribeSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void IncreaseReplicationFactorAsyncHelper(const Model::IncreaseReplicationFactorRequest& request, const IncreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListTagsAsyncHelper(const Model::ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void RebootNodeAsyncHelper(const Model::RebootNodeRequest& request, const RebootNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateClusterAsyncHelper(const Model::UpdateClusterRequest& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateParameterGroupAsyncHelper(const Model::UpdateParameterGroupRequest& request, const UpdateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void UpdateSubnetGroupAsyncHelper(const Model::UpdateSubnetGroupRequest& request, const UpdateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

      Aws::String m_uri;
      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
  };

} // namespace DAX
} // namespace Aws

redpajama_set_name: RedPajamaGithub


One of a kind, amazing 2 story on golf course lot with views of South Mountain! It shows like a model with a plethora of upgrades. Just a few of fabulous upgrades include: wrought iron entry door usually seen on custom homes, wood look tile through downstairs, granite counter tops, fresh paint, and the list goes on! Check the documents section for a complete list. Downstairs is open and spacious with a formal living entry that leads into the kitchen and great room. The master retreat is located upstairs and overlooks the golf course and has mountain views. The front bedroom has a balcony overlooking the front yard. Your buyers will love you for showing them this gem!


text:
Respond to the Smart Energy Transition Stay Secure Generate business value
Energy Applications Security Applications Smart Devices Professional Services Software Service & Maintenance
Whitepapers Datasheets Articles
Blog News / Articles Press Releases Videos / Podcasts Newsletter
About NES
Success Careers Contact Us
Environmental, Social and Corporate Governance (ESG)
Why NES Our Legacy Community ESG Management R&D
NES SUSTAINABILITY PLAN
Networked Energy Services' (NES) vision is to offer industry leading, high performing, cost effective and sustainable smart grid solutions with our proven and open 3 tier, multi-application platform.
For NES, this means using innovation to embed the concepts of eco-sustainability and digital inclusion into both our technology and throughout our business as an entity to enable the most efficient, reliable and secure delivery of energy for utilities.
We are committed to sustainable value creation and delivery by aligning our business strategy to meet societal needs while reducing environmental impact and advancing social development. This commitment is embedded in our company at every level:
as an integral part of customer satisfaction;
within innovation of products, software and services;
as a core pillar of our efficient operations; and
a fundamental part of our values and transparency.
Focus Areas for the Sustainability Management Plan
NES recognizes that the company-wide adherence to corporate responsibility and ethics are fundamental for business sustainability and ensures this is implemented throughout our Sustainability Management Plan.
NES' Sustainability Management Plan addresses economic, environmental, and social sustainability through key focus areas such as Environmental, Health and Safety Management (operational and product-related); Governance and Risk Management, Supply Chain, People and Workplace and Integrity and Ethics.
1. Environmental, Health and Safety Management
NES is greatly committed to following stringent Health, Safety and Environment (HSE) regulations. Therefore, NES has adopted a clear HSE Policy and established a comprehensive HSE Management System (HSEMS) compliant with legislation, regulations, standards (ISO9001, ISO14001 and OHSAS18001) and codes to manage HSE risks.
NES strives to protect our environment by providing quality products and services that minimize impact on the environment and maximize the sustainability of NEs' supply and service capability whilst protecting the health and safety of our employees. Moreover, NES is committed to continually monitor our HSE performance and to continually review its HSE policy with respect to future legislation and business opportunities.
Taking a holistic, end-to-end perspective, NES HSE and sustainability considerations and principles are embedded throughout our business value chain from: development of energy-efficient products; to sourcing materials; through to end-of-life recycling and waste disposal. Our approach enables our customers to operate at peak efficiency and performance, reducing the impact of our products and operations on the environment, providing a secure and safe work environment and create value for our stockholders by improving quality of life for our employees and end customers.
To achieve this NES has adopted a set of strategies:
Manage HSE hazards to improve our operations and performance and maintain the highest level of commitment to protecting the health and safety of our employees and end customers.
Commit to meet or exceed regulatory and policies outlined in the HSEMS. We work to create a sustainable workplace safety culture and focus our efforts to continuously enhance our health and safety performance.
Develop the most advanced energy efficient smart metering system which improves our employees' quality of life while undertaking proactive measures to minimize the environmental impact of both production and distribution activities. This is achieved by optimizing materials and components used and reducing waste emitted during production activities. To accomplish this objective, NES is working to make product designs more compact, lightweight, and efficient while simultaneously reducing the number of defective products created through manufacturing processes by implementing quality management initiatives within our product lifecycle such as the Zero Defects principle through our Contract Electronic Manufacturer (CEM).
As part of our design efforts, we strive to make use of recyclable materials wherever possible and to minimize internal power consumption. Some examples demonstrating NES' use of recyclable materials in NES meters include the meter cover and terminal block. The meter cover is made of ABS/PC plastic and is recyclable. The terminal block is made of polycarbonate plastic (with brass inserts) and is also recyclable. In fact, based on the weight of NES meters, approximately 80% of the meter is recyclable. In addition, NES uses recycled, recyclable, and/or reusable materials where practical for our product packaging and shipping.
Identify areas of continuous improvement associated with our approach to product development: NES conducts Life Cycle Assessments (LCA) when designing its eco-efficient and recyclable products to quantify and measure the environmental impact associated with all stages of our products' life cycles as well as constantly seek improvements in design, material selection and operating characteristics.
Examine non product specific aspects of the lifecycle including:
Proper planning, operation and safety practices such as eco efficient product packaging and transport economy are used throughout the shipping process.
Reducing the end-of-life environmental impact by providing product developers with design guidance and best practices for disassembly, reuse and recycling.
Meet our corporate social responsibility by improving health and safety, enhancing environmental awareness, and ensuring compliance with environmental legislation.
Raise awareness, and regularly refresh communications on key environmental and safety values and behaviors. Provide appropriate training and education for all employees regarding HSE issues, programs, and performance.
Actively promote recycling both internally and amongst our customers and suppliers, aiming to achieve zero emissions by improving recycling rates.
Work with our suppliers to establish and implement effective HSE performance goals in accordance with our ethical behavior and environmental principles and perform regular HSE field audits to determine whether the supplier is in compliance with NES recommended HSE practices.
Continuously improve HSE performance of our operations.
Put in place enterprise-wide policies and programs to reduce energy, water and materials use
Maximize waste recycling
Eliminate hazardous materials; and
Streamline logistics and packaging.
Integrate our HSE commitment into the company's decision-making processes and strive to continuously improve our commitment to the above-stated principles through exercise of our HSEMS, improved technology and production changes.
Review and update where necessary our HSE management system and policy on an annual basis. In addition,
Regularly monitor the HSE aspects of NES products, services and/or activities,
Identify key HSE risks and impacts,
Develop operational controls, and
Prepare emergency response and contingency plans to ensure that the HSE objectives and targets for quality, health, safety, and the environment are being met.
Ensure NES facilities provide planning, equipment and training for on-site incidents so that when necessary our employees can work with local community safety units to prepare for a combined response.
NES maintains full awareness of all relevant HSE issues together with their potential impact and strives to continuously improve HSE performance, stepping up efforts to innovate energy and environmental technologies contributing to the realization of a safe, secure and sustainable society.
2. Governance and Risk Management
a) Corporate Governance
NES is managed by a Board of Directors that establishes guidelines for Board operations and ethical conduct and supports all NES' initiatives covering a scope beyond what is meant by 'sustainability'.
The President and CEO (CEO), appointed by the Board of Directors, is responsible for handling the day-to-day management of NES in accordance with instructions from the Board of the Directors. The CEO is supported by the Senior Management Team (SMT).
The SMT is responsible for general management and governance, under the authority of the Board of Directors and the CEO.
On a monthly basis, the SMT reviews NES' governance principles and practices, sustainability priorities, strategy, KPIs and performance. The CEO, in collaboration with the SMT, provides oversight to the Board of Directors on global challenges, emerging and critical sustainability issues for the company with recommendations and seeks stakeholder feedback.
b) Risk Management
Embedding corporate responsibility and sustainability to NES' business activities require a robust and systematic approach to risk management to cover health and safety, social environmental and security impacts.
NES' risk management is based on identifying, analyzing, managing, and monitoring risks as well as preparing and acting on mitigatory action plans together with the sharing of best practices and processed across our business operations. Proactive management and effective control of risks is key to our success as it creates long term value and strengthens our business performance and resilience.
To reinforce its risk management system, NES has adopted a structured approach where the Board of Directors is responsible to oversee public policy, HSE and critical risks to sustainability, as well as to prioritize and review risk management activities on non-critical risks. The SMT is responsible for regular oversight of NES's operational, financial and strategic risks including conflict of interest policies, code of ethics together with compliance with laws and regulations. Every business unit along with its employees is in charge of controlling risks, including: identifying, mitigating, monitoring and, depending on the probability and severity of the risk, escalation as appropriate. Risk owners within each business unit are responsible to report on key risks to the SMT not less than annually.
NES supports its employees to implement a robust risk management system by ensuring they receive adequate trainings and follow both procedures and practical guidelines.
Our risk management approach is handled with a cyclical and on-going process that is integral to overall business continuity. Key components of this cycle are:
Initiate: Development of strong risk management policies and identification of existing and potential risks to the present effort.
Plan: Development of an effective risk management plan to identify, categorize, quantify, prioritize, and respond to risks and plan for contingency risks.
Change Management: Identifies and controls changes that could affect certain requirements, regulations, or add risk. BY reviewing our process we evaluate changes, conduct risk assessments and implement controls.
Execute: Execute the overall risk management plan and individual plans for specific risks that occur during the process.
Monitor and Control: Determine whether the implemented mitigating strategies are achieving the desired objective and provide corrective action if necessary.
Close: Close risks and issues as they are resolved and develop after action responses to further enhance risk mitigation in the future.
Document and Record Control: Standardizing documents as a process for ensuring the latest documents are being used, documents are being reviewed periodically, and new documents are properly approved.
Metrics: Create a set of metrics to drive improvements, focus resources on what is important and facilitate the transfer of best practices
NES risk management system address and mitigates the wide range of potential risks across our business and operations within the four main categories below:
Risks that affect or are created by our business strategy and strategic objectives and are associated with Corporate governance, Mergers and acquisitions, Intellectual property, Innovation and Technology, Competitors, Marketing, Sales, Program and Project, Sustainability and other strategic risks. By effectively managing strategic risks, NES can support the development and execution of the business strategy and help create value by maximizing gains and improving our competitive position.
NES addresses a variety of financial risks including risks in areas such as liquidity, assets, investments, volatility in foreign currency exchange rates, interest rate fluctuation, commodity price movement, credit movement and other markets changes, establishing a sustainable infrastructure to meet our financial and contractual obligations and manage the ever-changing regulatory and business environment while driving best performance and results year over year.
LEGAL & COMPLIANCE RISKS
Legal and compliance risks relate to legal and regulatory compliance and are enacted to ensure that organizations operate fairly and ethically, meeting its sustainability targets and compliance with environment HSE laws and regulations. NES' proactive, regulatory risk management is implemented through specific policies, procedures and protocols to ensure that NES is in compliance well in advance of regulatory changes. Dedicated procedures and business continuity plans are put in place to manage the appropriate response to identified key risks.
Compliance risks, also known as integrity risks include those associated with:
HSE Risks: NES has an integrated HSEM system that addresses process, compliance, and culture and is assessed on a rotational audit basis every three years. We focus on managing risks associated with evolving regulatory environment of carbon reduction, renewable energy standards and the need for increased sustainability by providing our energy efficient solutions and best management practices to reduce risks.
Social responsibility and Corruption Practices: NES CR and Sustainability program is in compliance with UN Global Code of Compact and management ensures NES is in compliance through regular monitoring by Human Resources.
Quality: NES manages product and service risks to ensure we comply with laws and regulations and meet or exceed the industry expected standards.
Process risks: NES actively monitors and manages the process risks to prevent failure and to meet our responsibilities to our customers and partners.
Operational risks can result from a breakdown of processes, inadequate activities by people, inadequate systems or from external events that affect the operation of our businesses. It includes information management, data protection and security, including cybersecurity, supply chain, product life cycle and execution, safety, performance, and other risks.
To minimize the risks arising from operational challenges, NES has put in place operational processes to ensure that our product design, manufacture and services meet the most rigorous quality standards. NES produces highly reliable, future proof, secure products and specialized services with leading edge technology. Our competitive position in the market is dependent on our ability to deliver innovative products and services, to customize them when needed and to anticipate and respond to market, regulations, eco environmental requirements as well as technological changes driven by emerging risks together with delivering products and services in line with our projected performance and cost estimates.
To protect customer services and consumer information, NES security follows a risk-based approach that tackles the real exposures and risks arising from a fast-moving threat-landscape. NES goes beyond merely achieving compliance to standards, because standards are slow-moving compared to the innovation of cyber-criminals and cyber-terrorists. Protection of our customers' information and service reliability remains a key focus for our security initiatives. NES' intrusion detection and response provides another mechanism to identify unauthorized access, limiting exposure to attacks and quickly locking out the attacker. Expert guidance is an important theme for NES as we continue to proactively conduct risk and vulnerability assessments based on our extensive experience of the changing threat landscape. Finally, with cyber-security regulations (such as GDPR) coming into effect in Q2 of 2018, NES offers its customers help in understanding how these regulations relate to their own compliance obligations.
Our reliance on third-party suppliers, manufacturers and service providers exposes us to volatility in the prices and availability of these components, goods, and services. To manage these risks, NES deploys a structured supply chain continuity program that develops guidelines, processes, tools and technology to support supplier continuity planning and tackles their financial, operational, environmental, and safety requirements. We also engage with our suppliers to identify, assess, manage and mitigate risks associated with HSE, quality, capability and sourcing issues and evaluate potential back up plans.
At NES, we believe that sustainability at its core is about analyzing, managing and mitigating risks and thus we ensure that quality assurance process is incorporated as a control mechanism over the risk management process. Quality assurance attributes that are followed during the risk management process are:
Strive to highlight all risks and their subsequent decisions through documentation and tracking on a centralized log.
Develop a complete audit trail of the risks.
Standards and procedures involved with the risk management process are being followed.
Risk status report is current.
Actions from the risk management process provide better quality control.
Corporate governance committee and each business unit is aware of the risks and their potential impact on the business and operation and how these risks should be mitigated.
3. Supply Chain
NES is fully committed to promoting sustainability throughout its supply chains and proactively works with its suppliers to support their adherence to sustainable business practices and share its best practices to forge balanced, mutually beneficial long-term relationships with them. We focus on purchasing components, products, software and services from the right suppliers who share our values and principles in all of the areas of social equity, ethics and environmental protection while ensuring they are operating according to accepted industry standards aligned with our policies and internal processes.
NES holds its suppliers to the highest standards and expects them to provide a significant and sustainable value contribution for the success of its business and to align with the set of requirements as below:
Comply with the UN global compacts principles and Commit to the Electronics Industry Citizenship Coalition (EICC) Code of conduct.
Meet certified international standards such as ISO 14001 for environment and OHSAS 18001 for health and safety.
Adhere to Sustainability performance.
Highest Capabilities in terms of On-time delivery, Service, Flexibility, Costs, Technical innovation, Quality, Overall business strength and productivity.
NES tracks compliance with these standards as part of our risk analysis and supplier assessment processes and strongly encourage suppliers to implement or enhance their sustainability practices based on them. To effectively promote sustainable practices and behaviors throughout our supply chain and drive improved performance, NES has adopted a comprehensive approach to responsible purchasing that stands on 3 pillars:
Regularly maintaining an open dialogue with suppliers, communicating clear sustainability requirements and managing their ongoing performance across a broad set of criteria.
Evaluate suppliers' sustainability performance through ratings, onsite audits and a self-assessment questionnaire concerning their engagement in the main areas of corporate responsibilities and environmental maturity.
Support suppliers' improvement efforts where performance is not at the expected level.
At NES, we strive for a best-in-class supply chain that enable us to move at the speed of our customers' needs and help us deliver the right solutions in the right way, while always maintaining the highest levels of quality and meeting our stances on social responsibility and ethics.
THE RAW MATERIALS INITIATIVE
NES has adopted the raw materials initiative which set out a strategy for addressing the issue of access to raw materials in the European Union (EU). This strategy has 3 pillars which aim to ensure:
1. Fair and sustainable supply of raw materials from global markets;
2. Sustainable supply of raw materials within the EU; and
3. Resource efficiency and supply of 'secondary raw materials' through recycling.
Our supply chain strategy covers raw materials used by European industries for production. We ensure sustainable access to these raw materials whilst maintaining the competitiveness and growth of raw materials sourced where possible in the EU. In addition, when NES sources raw material from outside the EU, priority is given to countries who have signed Letters of Intent with the EU regarding Raw Materials Diplomacy. Furthermore, NES is committed to promoting and increasing recycling within the production, Research and Development and administrative process. Recycling can reduce production costs and carbon emissions which we actively disclose through the Carbon Disclosure Project.
CARBON DISCLOSURE PROJECT
As a member of the Carbon Disclosure Project (CDP), NES actively taking steps towards building a climate safe, deforestation free, water secure future, with our carbon disclosure providing the bedrock for these ambitious actions. As the richest and most comprehensive dataset, CDP's data both fuels and tracks global progress towards building a truly sustainable economy for people and planet. By reporting to CDP, NES gains competitive advantage. Disclosure helps us stay ahead of regulatory and policy changes, identify and tackle growing risks and find new opportunities for action that our investors and customers worldwide are demanding. See Appendix 1.
4. Workplace, Inclusion and Diversity
At NES, the success of our company is driven by diverse and highly skilled workforce, customers and communities that supports the development of innovative approaches to a wide range of business and technological challenges. We believe innovation is strongly linked to diversity. Therefore, we are committed to creating a global workplace that encourages gender, cultural and generational diversity and embraces inclusion.
We believe that our employees' knowledge, skills and integrity are one of our most valuable assets and are key to ensuring NES' future success. For that we focus on:
Bringing diversity to our leadership positions as well as our overall workforce.
Bringing together talented and enthusiastic people from a variety of backgrounds and cultures.
Building a gender intelligent organization by attracting, developing and retaining more women as part of our overall workforce and at all levels of our management team.
Supporting competence development by creating a stimulating environment of continuous learning and enabling a work culture that supports our people so they can reach their greatest potential.
Encouraging open collaboration throughout the organization by using an internal social networking platform to enable employees throughout the company to share, collaborate and exchange best practices on each other's expertise and talents.
5. Integrity and Ethics
NES is committed to conducting business with integrity and with the highest ethical practices and standards of behavior. To achieve this, NES has a comprehensive Ethics & Compliance program that sets out fundamental policies, directives and practices for every NES employee in interactions with each other, customers, communities, and other stakeholders.
Key elements of this program includes:
NES Code of Conduct describes how employees fulfill the requirements for ethical conduct and compliance with company policies as well as all applicable laws and regulations. It also reflects our commitment to the UN Global Compact's principles and the United Nations' Guiding Principles on Business and Human Rights (UNGPs) and guides employee relationships internally and with external stakeholders.
Regularly communicating and reinforcing our commitment to ethics and compliance with applicable laws, rules and regulations, proper handling of proprietary data and information, and accurate financial reporting.
Annual all-employee training to ensure that every employee is aware of and following the program.
Annual Risks audit, assessment and mitigation plans to further optimize and streamline our compliance processes while preventing and detecting violations of law, regulation and company policy, and cultivating an ethical business culture throughout the company.
Policies, Procedures and controls including zero tolerance policy requiring 100% integrity in all business practices including adherence to the law and to our own internal regulations.
CDP is an organization that runs the global disclosure system for investors, companies, cities, states and regions to manage their environmental impacts. The world's economy looks to CDP as the gold standard of environmental reporting with the richest and most comprehensive dataset on corporate and city action.
CDP vision and mission
CDP want to see a thriving economy that works for people and planet in the long term. They focus investors, companies and cities on taking action to build a truly sustainable economy by measuring and understanding their environmental impact.
CDP values
1. They default to transparency
2. They place accountability at our heart
3. They learn and improve
4. They succeed together
We all must act urgently to prevent dangerous climate change and environmental damage. That starts by being aware of our impact so that investors, companies, cities and governments can make the right choices now.
What they do - "You can't manage what you don't measure".
CDP runs the global environmental disclosure system. Each year CDP supports thousands of companies, cities, states and regions to measure and manage their risks and opportunities on climate change, water security and deforestation. We do so at the request of their investors, purchasers and city stakeholders.
Over the last two decades we have created a system that has resulted in unparalleled engagement on environmental issues worldwide.
Each year, CDP takes the information supplied in its annual reporting process and scores companies and cities based on their journey through disclosure and towards environmental leadership. Through our independent scoring methodology, we measure corporate and city progress and incentivize action on climate change, forests and water security.
Founded in 2000, CDP was the first platform to link environmental integrity and fiduciary duty. Now with the world's largest, most comprehensive dataset on environmental action, the insights that CDP holds empowers investors, companies, cities, and national and regional governments to make the right choices today to build a thriving economy that works for people and planet in the long term.
Solution Respond to the Smart Energy Transition Stay Secure Generate business value Products & Services Energy Applications Security Applications Smart Devices Professional Services Software Service & Maintenance
Partners NES Grid Partners Development Partners Software Partners Alliances
Resources Whitepapers Datasheets Articles
News & Events Blog News / Articles Press Releases Videos / Podcasts Newsletter
About NES Why NES Our Legacy Community Management R&D Success Careers Contact Us
Support Sitemap Privacy & Cookie Policy Terms of Use
Solution Products & Services Energy Applications Security Applications Smart Meters Control Nodes Control Point Modules Software Service & Maintenance
Support About NES Why NES Our Legacy Community Management R&D
Success Partners NES Grid Partners Development Partners Software Partners Alliances
News & Events News / Articles Press Releases Videos Newsletter
Careers Sitemap Contact Us
Copyright © 2023. Networked Energy Services. All rights reserved.
Copyright © 2023 Networked Energy Services.

redpajama_set_name: RedPajamaCommonCrawl


Rachana Sansad School of Fashion Textile Design, Mumbai offers various graduate courses as well as Post Graduate courses.
List of facilities available at Rachana Sansad School of Fashion Textile Design, Mumbai for students.
This page was last modified on 9 March 2017 at 11:03.


text:
Interpretatio (Latijn) betekent vertaling of uitleg. Het wordt gebruikt als term voor:
 Een literaire werkwijze, zie translatio, imitatio en aemulatio
 Interpretatio Romana, het hernoemen van niet-Romeinse goden naar goden uit de Romeinse mythologie.

redpajama_set_name: RedPajamaWikipedia


text:
Table 268. Degrees conferred by degree-granting institutions, by level of degree and sex of student: Selected years, 1869-70 through 2018-19
Associate's degrees
First-professional degrees
Doctor's degrees1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
— — — 9,371 2 7,993 2 1,378 2 0 0 0 (3) (3) (3) 1 1 0
— — — 12,896 2 10,411 2 2,485 2 879 868 11 (3) (3) (3) 54 51 3
— — — 15,539 2 12,857 2 2,682 2 1,015 821 194 (3) (3) (3) 149 147 2
— — — 27,410 2 22,173 2 5,237 2 1,583 1,280 303 (3) (3) (3) 382 359 23
— — — 48,622 2 31,980 2 16,642 2 4,279 2,985 1,294 (3) (3) (3) 615 522 93
— — — 122,484 2 73,615 2 48,869 2 14,969 8,925 6,044 (3) (3) (3) 2,299 1,946 353
— — — 186,500 2 109,546 2 76,954 2 26,731 16,508 10,223 (3) (3) (3) 3,290 2,861 429
— — — 432,058 2 328,841 2 103,217 2 58,183 41,220 16,963 (3) (3) (3) 6,420 5,804 616
— — — 392,440 2 254,063 2 138,377 2 74,435 50,898 23,537 (3) (3) (3) 9,829 8,801 1,028
206,023 117,432 88,591 792,316 451,097 341,219 208,291 125,624 82,667 34,918 33,077 1,841 29,866 25,890 3,976
252,311 144,144 108,167 839,730 475,594 364,136 230,509 138,146 92,363 37,946 35,544 2,402 32,107 27,530 4,577
292,014 166,227 125,787 887,273 500,590 386,683 251,633 149,550 102,083 43,411 40,723 2,688 33,363 28,090 5,273
406,377 210,842 195,535 919,549 495,545 424,004 317,164 167,783 149,381 64,359 52,374 11,985 33,232 25,142 8,090
416,377 188,638 227,739 935,140 469,883 465,257 295,739 147,043 148,696 71,956 52,792 19,164 32,958 22,711 10,247
436,764 186,316 250,448 1,018,755 483,346 535,409 310,621 149,354 161,267 70,856 45,046 25,810 35,720 22,648 13,072
837,000 306,000 531,000 1,737,000 734,000 1,004,000 702,000 271,000 431,000 101,100 50,800 50,300 77,400 36,100 41,300
1 Includes Ph.D., Ed.D., and comparable degrees at the doctoral level. Excludes first-professional, such as M.D., D.D.S., and law degrees.
2 Includes first-professional degrees.
3 First-professional degrees are included with bachelor's degrees.
4 Projected.
NOTE: Data through 1994-95 are for institutions of higher education, while later data are for degree-granting institutions. Degree-granting institutions grant associate's or higher degrees and participate in Title IV federal financial aid programs. The degree-granting classification is very similar to the earlier higher education classification, but it includes more 2-year colleges and excludes a few higher education institutions that did not grant degrees. (See Appendix A: Guide to Sources for details.) Some data have been revised from previously published figures. Detail may not sum to totals because of rounding.
SOURCE: U.S. Department of Education, National Center for Education Statistics, Projections of Education Statistics to 2018; Higher Education General Information Survey (HEGIS), "Degrees and Other Formal Awards Conferred" surveys, 1965-66 through 1985-86; and 1986-87 through 2007-08 Integrated Postsecondary Education Data System, "Completions Survey" (IPEDS-C:87-99), and Fall 2000 through Fall 2008. (This table was prepared July 2009.)


If you are looking for a way to fast track a career in the rapidly growing medical field, then you should strongly consider earning your phlebotomy certification in Remington VA. According to the Bureau of Labor Statistics, Careers in the medical industry are expected to grow faster than any other industry between now and the year 2020. The overall job growth average is 14%, but for the medical field it's hovering at around 30%. So, phlebotomy training is your quick ticket to a stable career.
What are the Best Schools for Phlebotomy Certification in Remington VA?
The programs offered below are offered by premier, schools and come high recommended as viable options for most students.
If you're looking for a quick way to enter the nation's fastest growing job market, this is it. By earning your phlebotomy certification in Remington VA you will be setting yourself up for a career in the medical field that pays well and offers long term stability.
Reviewed by: Mclane Whitesel on Nov 08.
Awesome source boiling over with unbelievable crazy good information!
Thanks a lot for releasing such a awesome resource. I was able to research what I wanted. This web site has made things way easier.


"Beautiful place with a small trek"
"Superb and big place to see"
"The most beautiful place which I ever seen "
Munnar is mostly preferred by travellers. The go to destination for types of travellers, be it family, kids and couples. Munnar is, however, mostly preferred by Couple, Group. The best season or months to visit places in Munnar are February, March, April, May, August, September, October, November, December. There are 65 tourist places in Munnar, which can be explored by travellers. Local attractions can be visited at any time of the day, be it early morning, afternoon, evening or night, as suitable for travellers. Sightseeing in Munnar can be done by travellers, which will take half a day or one day, but to see all sightseeing places, travellers need to stay in Munnar for 2 days to 3 days.
Travellers can also visit Munnar to learn about places to visit, browse through photos & pictures, explore Munnar using a map and read sightseeing reviews. Recently reviewed tourist attractions in Munnar, which are great places to visit are Kanan Devan Hills Plantations Tea Museum, Munnar, Anayirnkal Dam, Munnar Spices And Ayurvedic Garden, Kalvari Mount. Munnar can be visited in summer, monsoon or winter.


text:
The wonder and wander of research
The word "research" first appeared in the English language sometime during the 16th century. It comes from the Latin word "circare," which means "to go about and wander." So really, research is all about wandering.
But research that is commercially and politically popular has a different agenda. That agenda is oriented towards the development of new technology, tools, and cures. Such as, for example, vacuum cleaners.
However, before Daniel Hess could invent the vacuum cleaner (or "carpet sweeper" as it was called back then); several advancements in science and technology had to be made. For instance, the inventor had to have at least known that suction is caused by a difference in air pressure. I don't study vacuum cleaners, but I do ask myself how important my research is, and what impact it might really have on society.
Briefly (I'll be less brief in a later post), I am studying how a certain molecule characterized in the immune (called TNF-alpha), regulates neurotransmission. Neurotransmission (or "synaptic transmission") is the cellular mechanism that is thought to underlie learning and memory. Why did I decide to do this research? Well, I was generally curious about how the brain produces complex behavior from a bunch of tiny molecules and brain cells.
Curiosity is surely the driving force behind many a scientists' motivation, rather than the relevance of their research to the world outside of academia. But in the field of life sciences, there is an enormous pressure to make research relevant to some disease or pathology. Government and funding agencies are increasingly interested in impact-oriented research. This limits the ability of scientists to initiate creative or novel research, and undermines curiosity-based scientific inquiry.
New Yorker Cartoon Poster Print by Leo Cullum
There is nothing wrong with having goal-oriented research and development to solve specific problems. But it is important to realize that investment in fundamental or basic research is essential for laying the foundation for the discoveries of the future.
Curiosity-driven research might often appear to provide no obvious benefits to society, but history teaches us the value of serendipity or "wander and wonder" in science.
One of my favorite examples of curiosity-driven research is the case of the Green Fluorescent Protein (GFP). Basically, a scientist in the 1960s was wondering what made a certain species of jellyfish glow green. He eventually discovered and characterized GFP, which at first, didn't amount to much.
Then, another scientist realized that this could be used as an ideal cellular beacon to track the localization of specific cells or molecules inside living organisms. Fast forward to 2008 and these scientists won the Nobel Prize!
I'm certainly not holding out to win the Nobel Prize in 40 years, but I do think that the tiny, seemingly irrelevant details about neurotransmission that I am studying today will eventually be part of future scientific breakthroughs.
(On a side note, it is still not known why jellyfish glow green…)
Tags: curiosity-driven, jellyfish, Sarah Konefal
Published by sarahkonefal on 2013/11/17 at 6:15 PM under General Discussions, Grad school experience, Research.


text:
Contemporary management of atrial fibrillation: update on anticoagulation and invasive management strategies
Mark A Crandall, David J Bradley, Douglas L Packer, Samuel J Asirvatham
Mayo Clinic Proceedings 2009, 84 (7): 643-62
Atrial fibrillation (AF) is the most common arrhythmia encountered in clinical practice. Its increasing prevalence, particularly among the elderly, renders it one of the most serious current medical epidemics. Several management questions confront the clinician treating a patient with AF: Should the condition be treated? Is the patient at risk of death or serious morbidity as a result of this diagnosis? If treatment is necessary, is rate control or rhythm control superior? Which patients need anticoagulation therapy, and for how long? This review of articles obtained by a search of the PubMed and MEDLINE databases presents the available evidence that can guide the clinician in answering these questions. After discussing the merits of available therapy, including medications aimed at controlling rate, rhythm, or both, we focus on the present status of ablative therapy for AF. Catheter ablation, particularly targeting the pulmonary veins, is being increasingly performed, although the precise indications for this approach and its effectiveness and safety are being actively investigated. We briefly discuss other invasive options that are less frequently used, such as pacemakers, defibrillators, left atrial appendage closure devices, and the surgical maze procedure.
[Atrila fibrillation: a review]. C B Brunckhorst, J Holzmeister, Ch Scharf, Ch Binggeli, J P Hellermann, F Duru Praxis 2004 May 5, 93 (19): 803-15
[Atrial fibrillation: the most common arrhythmia]. Jean-Yves Le Heuzey, Akli Otmani, Eloi Marijon, Xavier Waintraub, Antoine Lepillier, Karim Chachoua, Thomas Lavergne, Maurice Pornin La Presse Médicale 2008, 37 (5 Pt 2): 821-6
Non-pharmacologic management of atrial fibrillation. Andrew J Brenyo, Mehmet K Aktas American Journal of Cardiology 2011 July 15, 108 (2): 317-25
Current management of symptomatic atrial fibrillation. D Haghi, B Schumacher American Journal of Cardiovascular Drugs: Drugs, Devices, and Other Interventions 2001, 1 (2): 127-39
Cardioversion in atrial fibrillation. Focus on recent-onset atrial fibrillation. Andrea Tampieri, Anna Maria Rusconi, Tiziano Lenzi Internal and Emergency Medicine 2012, 7 Suppl 3: S241-50
Treating atrial fibrillation. What is the consensus now? Indranill Basu Ray, E Kevin Heist Postgraduate Medicine 2005, 118 (4): 47-8, 51-4, 58
Curative catheter ablation in atrial fibrillation and typical atrial flutter: systematic review and economic evaluation. M Rodgers, C McKenna, S Palmer, D Chambers, S Van Hout, S Golder, C Pepper, D Todd, N Woolacott Health Technology Assessment: HTA 2008, 12 (34): iii-iv, xi-xiii, 1-198
[Atrial fibrillation: current recommendations for diagnosis and treatment]. P Kirchhof Der Internist 2013, 54 (5): 583-95
Management of atrial fibrillation: therapeutic options and clinical decisions. E N Prystowsky American Journal of Cardiology 2000 May 25, 85 (10): 3D-11D
Atrial fibrillation: diagnosis and treatment. Cecilia Gutierrez, Daniel G Blanchard American Family Physician 2011 January 1, 83 (1): 61-8


Just off Route 51, near Century III Mall.
This orientation, hosted by Dr. Amy Maddalena, is a great way for people we've never met to get to know us, learn what we're all about, and see why Kids Plus is Pittsburgh's most caring, connected, and comprehensive pediatric practice.
Moms meet with one of our International Board Certified Lactation Consultants, who will discuss breastfeeding basics, hold a question/answer session, as well as show and discuss various breastfeeding pumps and supplies. Classes are FREE and open to the public.
You provide the kids. We'll provide the crafts. (And the fun!) Build a simple, fun, kid-friendly art project. Bring your kids, turn your cell phone off — ok, just put it on vibrate! — and enjoy creating a masterpiece together. The best part is, the mess isn't at your house! Recommended for Kids up to Age 10.


text:
Taylor Swift looks stunning as a bridesmaid for BFF Abigail Anderson's wedding -- See the pics!
Liz Calvario
Sep 3rd 2017 12:02PM
Taylor Swift is the ultimate bridesmaid!
The 27-year-old singer was spotted in Martha's Vineyard, Massachusetts, on Saturday, accompanying her best friend, Abigail Anderson, on her wedding day.
EXCLUSIVE: Taylor Swift's Director Joseph Kahn on How Beauty & Brains Hurt Her Credibility
Wearing a lovely burgundy sweetheart top maxi dress, with her curled golden locks and signature red lipstick, Swift held the back of Anderson's wedding dress while entering the church for the ceremony. It's unknown if Swift was the maid of honor.
RELATED: Taylor Swift's BFF Abigail Anderson Is Engaged -- See the Sweet Pics!
The "Look What You Made Me Do" singer and Anderson have been BFF's since high school, Swift even added Abigail's name to her song "Fifteen."
RELATED: Throwback photos of Taylor Swift
Taylor Swift tbt
Credit: Splash News
Anderson announced her engagement in June of 2016 with a romantic Instagram pic of herself and fiancé Matt Lucier kissing, while showing off her ring. The newly-engaged couple then threw an engagement party, which Swift attended.
When there's literally so much love around your only option is to make a room for all of your love banners & sing love songs to each other. @taylorswift we LOVE you! Kudos to @teddysphotos for the photobomb of the year.
A post shared by Abigail Anderson Lucier (@abigail_lauren) on Jul 5, 2016 at 3:01pm PDT
The bride celebrated her bachelorette party in Cabo San Lucas, Baja California, at the end of July, though based on Anderson's Instagram snaps, Swift was not present.
🏝🏝🏝
A post shared by Abigail Anderson Lucier (@abigail_lauren) on Jul 31, 2017 at 7:46am PDT
Swift is currently gearing up to release her sixth studio album, Reputation, on Nov. 10. Her first single from the LP, "Look What You Made Me Do," and its accompanying video, has been the topic of much discussion.
Taylor Swift and Lorde together
BEVERLY HILLS, CA - FEBRUARY 28: Taylor Swift and Lorde attend the 2016 Vanity Fair Oscar Party Hosted By Graydon Carter at Wallis Annenberg Center for the Performing Arts on February 28, 2016 in Beverly Hills, California. (Photo by Karwai Tang/WireImage)
New Zealander singer Lorde (R) and US singer Taylor Swift pose as they arrive to the 2016 Vanity Fair Oscar Party in Beverly Hills, California on February 28, 2016. / AFP / ADRIAN SANCHEZ-GONZALEZ (Photo credit should read ADRIAN SANCHEZ-GONZALEZ/AFP/Getty Images)
WASHINGTON, DC - JULY 13: Taylor Swift and Lorde perform onstage during The 1989 World Tour Live at Nationals Park on July 13, 2015 in Washington DC. (Photo by Kris Connor/LP5/Getty Images for TAS)
BEVERLY HILLS, CA - JANUARY 11: Actress Jaime King, singers Lorde and Taylor Swift arrive at the 16th Annual Warner Bros. And InStyle Post-Golden Globe Party at The Beverly Hilton Hotel on January 11, 2015 in Beverly Hills, California. (Photo by Gregg DeGuire/WireImage)
BEVERLY HILLS, CA - JANUARY 11: (L-R) Recording artist Taylor Swift, musician Este Haim, actress Jaime King, producer Harvey Weinstein and recording artist Lorde attend The Weinstein Company's 2015 Golden Globe Awards After Party with Moet & Chandon at The Beverly Hilton Hotel on January 11, 2015 in Beverly Hills, California. (Photo by Michael Kovac/Getty Images for Moet & Chandon)
LOS ANGELES, CA - NOVEMBER 23: (L-R) Singer Lorde, model Karlie Kloss, singer Taylor Swift and singer Sam Smith in the audience at the 2014 American Music Awards at Nokia Theatre L.A. Live on November 23, 2014 in Los Angeles, California. (Photo by Christopher Polk/AMA2014/Getty Images for DCP)
LOS ANGELES, CA - NOVEMBER 23: (L-R) Singers Lorde, Selena Gomez and Taylor Swift attend the 2014 American Music Awards at Nokia Theatre L.A. Live on November 23, 2014 in Los Angeles, California. (Photo by Jeff Kravitz/AMA2014/FilmMagic)
LOS ANGELES, CA - NOVEMBER 23: Singers Lorde (L) and Taylor Swift attend the 2014 American Music Awards at Nokia Theatre L.A. Live on November 23, 2014 in Los Angeles, California. (Photo by Jeff Kravitz/AMA2014/FilmMagic)
INGLEWOOD, CA - AUGUST 24: (L-R) Recording artists Taylor Swift, Lorde and guest take a selfie at the 2014 MTV Video Music Awards at The Forum on August 24, 2014 in Inglewood, California. (Photo by Jeff Kravitz/MTV1415/FilmMagic)
INGLEWOOD, CA - AUGUST 24: Singers Taylor Swift (L) and Lorde attend the 2014 MTV Video Music Awards at The Forum on August 24, 2014 in Inglewood, California. (Photo by Larry Busacca/MTV1415/Getty Images for MTV)
INGLEWOOD, CA - AUGUST 24: Lorde and Taylor Swift attend the 2014 MTV Video Music Awards at The Forum on August 24, 2014 in Inglewood, California. (Photo by Kevin Mazur/MTV1415/WireImage)
LOS ANGELES, CA - JANUARY 26: Taylor Swift and Lorde attends the 56th GRAMMY Awards at Staples Center on January 26, 2014 in Los Angeles, California. (Photo by Kevin Mazur/WireImage)
BEVERLY HILLS, CA - JANUARY 25: Recording artists Lorde (L) and Taylor Swift attend the 56th annual GRAMMY Awards Pre-GRAMMY Gala and Salute to Industry Icons honoring Lucian Grainge at The Beverly Hilton on January 25, 2014 in Beverly Hills, California. (Photo by Larry Busacca/Getty Images for NARAS)