text:
#pragma once
#include <aws/health/Health_EXPORTS.h>
#include <aws/health/HealthErrors.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/health/model/DescribeAffectedAccountsForOrganizationResult.h>
#include <aws/health/model/DescribeAffectedEntitiesResult.h>
#include <aws/health/model/DescribeAffectedEntitiesForOrganizationResult.h>
#include <aws/health/model/DescribeEntityAggregatesResult.h>
#include <aws/health/model/DescribeEventAggregatesResult.h>
#include <aws/health/model/DescribeEventDetailsResult.h>
#include <aws/health/model/DescribeEventDetailsForOrganizationResult.h>
#include <aws/health/model/DescribeEventTypesResult.h>
#include <aws/health/model/DescribeEventsResult.h>
#include <aws/health/model/DescribeEventsForOrganizationResult.h>
#include <aws/health/model/DescribeHealthServiceStatusForOrganizationResult.h>
#include <aws/core/NoResult.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 Health
{

namespace Model
{
        class DescribeAffectedAccountsForOrganizationRequest;
        class DescribeAffectedEntitiesRequest;
        class DescribeAffectedEntitiesForOrganizationRequest;
        class DescribeEntityAggregatesRequest;
        class DescribeEventAggregatesRequest;
        class DescribeEventDetailsRequest;
        class DescribeEventDetailsForOrganizationRequest;
        class DescribeEventTypesRequest;
        class DescribeEventsRequest;
        class DescribeEventsForOrganizationRequest;

        typedef Aws::Utils::Outcome<DescribeAffectedAccountsForOrganizationResult, HealthError> DescribeAffectedAccountsForOrganizationOutcome;
        typedef Aws::Utils::Outcome<DescribeAffectedEntitiesResult, HealthError> DescribeAffectedEntitiesOutcome;
        typedef Aws::Utils::Outcome<DescribeAffectedEntitiesForOrganizationResult, HealthError> DescribeAffectedEntitiesForOrganizationOutcome;
        typedef Aws::Utils::Outcome<DescribeEntityAggregatesResult, HealthError> DescribeEntityAggregatesOutcome;
        typedef Aws::Utils::Outcome<DescribeEventAggregatesResult, HealthError> DescribeEventAggregatesOutcome;
        typedef Aws::Utils::Outcome<DescribeEventDetailsResult, HealthError> DescribeEventDetailsOutcome;
        typedef Aws::Utils::Outcome<DescribeEventDetailsForOrganizationResult, HealthError> DescribeEventDetailsForOrganizationOutcome;
        typedef Aws::Utils::Outcome<DescribeEventTypesResult, HealthError> DescribeEventTypesOutcome;
        typedef Aws::Utils::Outcome<DescribeEventsResult, HealthError> DescribeEventsOutcome;
        typedef Aws::Utils::Outcome<DescribeEventsForOrganizationResult, HealthError> DescribeEventsForOrganizationOutcome;
        typedef Aws::Utils::Outcome<DescribeHealthServiceStatusForOrganizationResult, HealthError> DescribeHealthServiceStatusForOrganizationOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, HealthError> DisableHealthServiceAccessForOrganizationOutcome;
        typedef Aws::Utils::Outcome<Aws::NoResult, HealthError> EnableHealthServiceAccessForOrganizationOutcome;

        typedef std::future<DescribeAffectedAccountsForOrganizationOutcome> DescribeAffectedAccountsForOrganizationOutcomeCallable;
        typedef std::future<DescribeAffectedEntitiesOutcome> DescribeAffectedEntitiesOutcomeCallable;
        typedef std::future<DescribeAffectedEntitiesForOrganizationOutcome> DescribeAffectedEntitiesForOrganizationOutcomeCallable;
        typedef std::future<DescribeEntityAggregatesOutcome> DescribeEntityAggregatesOutcomeCallable;
        typedef std::future<DescribeEventAggregatesOutcome> DescribeEventAggregatesOutcomeCallable;
        typedef std::future<DescribeEventDetailsOutcome> DescribeEventDetailsOutcomeCallable;
        typedef std::future<DescribeEventDetailsForOrganizationOutcome> DescribeEventDetailsForOrganizationOutcomeCallable;
        typedef std::future<DescribeEventTypesOutcome> DescribeEventTypesOutcomeCallable;
        typedef std::future<DescribeEventsOutcome> DescribeEventsOutcomeCallable;
        typedef std::future<DescribeEventsForOrganizationOutcome> DescribeEventsForOrganizationOutcomeCallable;
        typedef std::future<DescribeHealthServiceStatusForOrganizationOutcome> DescribeHealthServiceStatusForOrganizationOutcomeCallable;
        typedef std::future<DisableHealthServiceAccessForOrganizationOutcome> DisableHealthServiceAccessForOrganizationOutcomeCallable;
        typedef std::future<EnableHealthServiceAccessForOrganizationOutcome> EnableHealthServiceAccessForOrganizationOutcomeCallable;
} // namespace Model

  class HealthClient;

    typedef std::function<void(const HealthClient*, const Model::DescribeAffectedAccountsForOrganizationRequest&, const Model::DescribeAffectedAccountsForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeAffectedAccountsForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeAffectedEntitiesRequest&, const Model::DescribeAffectedEntitiesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeAffectedEntitiesResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeAffectedEntitiesForOrganizationRequest&, const Model::DescribeAffectedEntitiesForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeAffectedEntitiesForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEntityAggregatesRequest&, const Model::DescribeEntityAggregatesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEntityAggregatesResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventAggregatesRequest&, const Model::DescribeEventAggregatesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventAggregatesResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventDetailsRequest&, const Model::DescribeEventDetailsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventDetailsResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventDetailsForOrganizationRequest&, const Model::DescribeEventDetailsForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventDetailsForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventTypesRequest&, const Model::DescribeEventTypesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventTypesResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventsRequest&, const Model::DescribeEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventsResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeEventsForOrganizationRequest&, const Model::DescribeEventsForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEventsForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DescribeHealthServiceStatusForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeHealthServiceStatusForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::DisableHealthServiceAccessForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisableHealthServiceAccessForOrganizationResponseReceivedHandler;
    typedef std::function<void(const HealthClient*, const Model::EnableHealthServiceAccessForOrganizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > EnableHealthServiceAccessForOrganizationResponseReceivedHandler;

  /**
   * <fullname>AWS Health</fullname>
The AWS Health API provides programmatic
   * access to the AWS Health information that appears in the AWS Personal Health Dashboard.
   * You can use the API operations to get information about AWS Health events that
   * affect your AWS services and resources.

You must have a
   * Business or Enterprise Support plan from AWS Support to use the AWS
   * Health API. If you call the AWS Health API from an AWS account that doesn't have
   * a Business or Enterprise Support plan, you receive a
   * SubscriptionRequiredException error.

You can use
   * the AWS Health endpoint health.us-east-1.amazonaws.com (HTTPS) to call the AWS
   * Health API operations. AWS Health supports a multi-Region application
   * architecture and has two regional endpoints in an active-passive configuration.
   * You can use the high availability endpoint example to determine which AWS Region
   * is active, so that you can get the latest information from the API. For more
   * information, see Accessing
   * the AWS Health API in the AWS Health User Guide.

   *
For authentication of requests, AWS Health uses the Signature
   * Version 4 Signing Process.

If your AWS account is part of AWS
   * Organizations, you can use the AWS Health organizational view feature. This
   * feature provides a centralized view of AWS Health events across all accounts in
   * your organization. You can aggregate AWS Health events in real time to identify
   * accounts in your organization that are affected by an operational event or get
   * notified of security vulnerabilities. Use the organizational view API operations
   * to enable this feature and return event information. For more information, see
   * Aggregating
   * AWS Health events in the AWS Health User Guide.

When
   * you use the AWS Health API operations to return AWS Health events, see the
   * following recommendations:

Use the eventScopeCode
   * parameter to specify whether to return AWS Health events that are public or
   * account-specific.

Use pagination to view all events from the
   * response. For example, if you call the
   * DescribeEventsForOrganization operation to get all events in your
   * organization, you might receive several page results. Specify the
   * nextToken in the next request to return more results.

   *

   */
  class AWS_HEALTH_API HealthClient : 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.
        */
        HealthClient(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.
        */
        HealthClient(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
        */
        HealthClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

        virtual ~HealthClient();

        /**
         *
Returns a list of accounts in the organization from AWS Organizations that
         * are affected by the provided event. For more information about the different
         * types of AWS Health events, see Event.
         *

Before you can call this operation, you must first enable AWS Health to
         * work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeAffectedAccountsForOrganizationOutcome DescribeAffectedAccountsForOrganization(const Model::DescribeAffectedAccountsForOrganizationRequest& request) const;

        /**
         *
Returns a list of accounts in the organization from AWS Organizations that
         * are affected by the provided event. For more information about the different
         * types of AWS Health events, see Event.
         *

Before you can call this operation, you must first enable AWS Health to
         * work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns a list of accounts in the organization from AWS Organizations that
         * are affected by the provided event. For more information about the different
         * types of AWS Health events, see Event.
         *

Before you can call this operation, you must first enable AWS Health to
         * work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns a list of entities that have been affected by the specified events,
         * based on the specified filter criteria. Entities can refer to individual
         * customer resources, groups of customer resources, or any other construct,
         * depending on the AWS service. Events that have impact beyond that of the
         * affected entities, or where the extent of impact is unknown, include at least
         * one entity indicating this.

At least one event ARN is required. Results
         * are sorted by the lastUpdatedTime of the entity, starting with the
         * most recent.

This API operation uses pagination. Specify
         * the nextToken parameter in the next request to return more
         * results.

This operation supports resource-level permissions.
         * You can use this operation to allow or deny access to specific AWS Health
         * events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeAffectedEntitiesOutcome DescribeAffectedEntities(const Model::DescribeAffectedEntitiesRequest& request) const;

        /**
         *
Returns a list of entities that have been affected by the specified events,
         * based on the specified filter criteria. Entities can refer to individual
         * customer resources, groups of customer resources, or any other construct,
         * depending on the AWS service. Events that have impact beyond that of the
         * affected entities, or where the extent of impact is unknown, include at least
         * one entity indicating this.

At least one event ARN is required. Results
         * are sorted by the lastUpdatedTime of the entity, starting with the
         * most recent.

This API operation uses pagination. Specify
         * the nextToken parameter in the next request to return more
         * results.

This operation supports resource-level permissions.
         * You can use this operation to allow or deny access to specific AWS Health
         * events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns a list of entities that have been affected by the specified events,
         * based on the specified filter criteria. Entities can refer to individual
         * customer resources, groups of customer resources, or any other construct,
         * depending on the AWS service. Events that have impact beyond that of the
         * affected entities, or where the extent of impact is unknown, include at least
         * one entity indicating this.

At least one event ARN is required. Results
         * are sorted by the lastUpdatedTime of the entity, starting with the
         * most recent.

This API operation uses pagination. Specify
         * the nextToken parameter in the next request to return more
         * results.

This operation supports resource-level permissions.
         * You can use this operation to allow or deny access to specific AWS Health
         * events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns a list of entities that have been affected by one or more events for
         * one or more accounts in your organization in AWS Organizations, based on the
         * filter criteria. Entities can refer to individual customer resources, groups of
         * customer resources, or any other construct, depending on the AWS service.

         *
At least one event Amazon Resource Name (ARN) and account ID are required.
         * Results are sorted by the lastUpdatedTime of the entity, starting
         * with the most recent.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

         *
This API operation uses pagination. Specify the nextToken
         * parameter in the next request to return more results.

This
         * operation doesn't support resource-level permissions. You can't use this
         * operation to allow or deny access to specific AWS Health events. For more
         * information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeAffectedEntitiesForOrganizationOutcome DescribeAffectedEntitiesForOrganization(const Model::DescribeAffectedEntitiesForOrganizationRequest& request) const;

        /**
         *
Returns a list of entities that have been affected by one or more events for
         * one or more accounts in your organization in AWS Organizations, based on the
         * filter criteria. Entities can refer to individual customer resources, groups of
         * customer resources, or any other construct, depending on the AWS service.

         *
At least one event Amazon Resource Name (ARN) and account ID are required.
         * Results are sorted by the lastUpdatedTime of the entity, starting
         * with the most recent.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

         *
This API operation uses pagination. Specify the nextToken
         * parameter in the next request to return more results.

This
         * operation doesn't support resource-level permissions. You can't use this
         * operation to allow or deny access to specific AWS Health events. For more
         * information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns a list of entities that have been affected by one or more events for
         * one or more accounts in your organization in AWS Organizations, based on the
         * filter criteria. Entities can refer to individual customer resources, groups of
         * customer resources, or any other construct, depending on the AWS service.

         *
At least one event Amazon Resource Name (ARN) and account ID are required.
         * Results are sorted by the lastUpdatedTime of the entity, starting
         * with the most recent.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

         *
This API operation uses pagination. Specify the nextToken
         * parameter in the next request to return more results.

This
         * operation doesn't support resource-level permissions. You can't use this
         * operation to allow or deny access to specific AWS Health events. For more
         * information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the number of entities that are affected by each of the specified
         * events. If no events are specified, the counts of all affected entities are
         * returned.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEntityAggregatesOutcome DescribeEntityAggregates(const Model::DescribeEntityAggregatesRequest& request) const;

        /**
         *
Returns the number of entities that are affected by each of the specified
         * events. If no events are specified, the counts of all affected entities are
         * returned.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the number of entities that are affected by each of the specified
         * events. If no events are specified, the counts of all affected entities are
         * returned.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the number of events of each event type (issue, scheduled change, and
         * account notification). If no filter is specified, the counts of all events in
         * each category are returned.

This API operation uses pagination.
         * Specify the nextToken parameter in the next request to return more
         * results.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventAggregatesOutcome DescribeEventAggregates(const Model::DescribeEventAggregatesRequest& request) const;

        /**
         *
Returns the number of events of each event type (issue, scheduled change, and
         * account notification). If no filter is specified, the counts of all events in
         * each category are returned.

This API operation uses pagination.
         * Specify the nextToken parameter in the next request to return more
         * results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the number of events of each event type (issue, scheduled change, and
         * account notification). If no filter is specified, the counts of all events in
         * each category are returned.

This API operation uses pagination.
         * Specify the nextToken parameter in the next request to return more
         * results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns detailed information about one or more specified events. Information
         * includes standard event data (AWS Region, service, and so on, as returned by DescribeEvents),
         * a detailed event description, and possible additional metadata that depends upon
         * the nature of the event. Affected entities are not included. To retrieve the
         * entities, use the DescribeAffectedEntities
         * operation.

If a specified event can't be retrieved, an error message is
         * returned for that event.

This operation supports resource-level
         * permissions. You can use this operation to allow or deny access to specific AWS
         * Health events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventDetailsOutcome DescribeEventDetails(const Model::DescribeEventDetailsRequest& request) const;

        /**
         *
Returns detailed information about one or more specified events. Information
         * includes standard event data (AWS Region, service, and so on, as returned by DescribeEvents),
         * a detailed event description, and possible additional metadata that depends upon
         * the nature of the event. Affected entities are not included. To retrieve the
         * entities, use the DescribeAffectedEntities
         * operation.

If a specified event can't be retrieved, an error message is
         * returned for that event.

This operation supports resource-level
         * permissions. You can use this operation to allow or deny access to specific AWS
         * Health events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns detailed information about one or more specified events. Information
         * includes standard event data (AWS Region, service, and so on, as returned by DescribeEvents),
         * a detailed event description, and possible additional metadata that depends upon
         * the nature of the event. Affected entities are not included. To retrieve the
         * entities, use the DescribeAffectedEntities
         * operation.

If a specified event can't be retrieved, an error message is
         * returned for that event.

This operation supports resource-level
         * permissions. You can use this operation to allow or deny access to specific AWS
         * Health events. For more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns detailed information about one or more specified events for one or
         * more AWS accounts in your organization. This information includes standard event
         * data (such as the AWS Region and service), an event description, and (depending
         * on the event) possible metadata. This operation doesn't return affected
         * entities, such as the resources related to the event. To return affected
         * entities, use the DescribeAffectedEntitiesForOrganization
         * operation.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

When you
         * call the DescribeEventDetailsForOrganization operation, specify the
         * organizationEventDetailFilters object in the request. Depending on
         * the AWS Health event type, note the following differences:

To
         * return event details for a public event, you must specify a null value for the
         * awsAccountId parameter. If you specify an account ID for a public
         * event, AWS Health returns an error message because public events aren't specific
         * to an account.

To return event details for an event that is
         * specific to an account in your organization, you must specify the
         * awsAccountId parameter in the request. If you don't specify an
         * account ID, AWS Health returns an error message because the event is specific to
         * an account in your organization.

For more information, see
         * Event.

         *
This operation doesn't support resource-level permissions. You can't
         * use this operation to allow or deny access to specific AWS Health events. For
         * more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventDetailsForOrganizationOutcome DescribeEventDetailsForOrganization(const Model::DescribeEventDetailsForOrganizationRequest& request) const;

        /**
         *
Returns detailed information about one or more specified events for one or
         * more AWS accounts in your organization. This information includes standard event
         * data (such as the AWS Region and service), an event description, and (depending
         * on the event) possible metadata. This operation doesn't return affected
         * entities, such as the resources related to the event. To return affected
         * entities, use the DescribeAffectedEntitiesForOrganization
         * operation.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

When you
         * call the DescribeEventDetailsForOrganization operation, specify the
         * organizationEventDetailFilters object in the request. Depending on
         * the AWS Health event type, note the following differences:

To
         * return event details for a public event, you must specify a null value for the
         * awsAccountId parameter. If you specify an account ID for a public
         * event, AWS Health returns an error message because public events aren't specific
         * to an account.

To return event details for an event that is
         * specific to an account in your organization, you must specify the
         * awsAccountId parameter in the request. If you don't specify an
         * account ID, AWS Health returns an error message because the event is specific to
         * an account in your organization.

For more information, see
         * Event.

         *
This operation doesn't support resource-level permissions. You can't
         * use this operation to allow or deny access to specific AWS Health events. For
         * more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns detailed information about one or more specified events for one or
         * more AWS accounts in your organization. This information includes standard event
         * data (such as the AWS Region and service), an event description, and (depending
         * on the event) possible metadata. This operation doesn't return affected
         * entities, such as the resources related to the event. To return affected
         * entities, use the DescribeAffectedEntitiesForOrganization
         * operation.

Before you can call this operation, you must first
         * enable AWS Health to work with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

When you
         * call the DescribeEventDetailsForOrganization operation, specify the
         * organizationEventDetailFilters object in the request. Depending on
         * the AWS Health event type, note the following differences:

To
         * return event details for a public event, you must specify a null value for the
         * awsAccountId parameter. If you specify an account ID for a public
         * event, AWS Health returns an error message because public events aren't specific
         * to an account.

To return event details for an event that is
         * specific to an account in your organization, you must specify the
         * awsAccountId parameter in the request. If you don't specify an
         * account ID, AWS Health returns an error message because the event is specific to
         * an account in your organization.

For more information, see
         * Event.

         *
This operation doesn't support resource-level permissions. You can't
         * use this operation to allow or deny access to specific AWS Health events. For
         * more information, see Resource-
         * and action-based conditions in the AWS Health User Guide.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the event types that meet the specified filter criteria. You can use
         * this API operation to find information about the AWS Health event, such as the
         * category, AWS service, and event code. The metadata for each event appears in
         * the EventType
         * object.

If you don't specify a filter criteria, the API operation
         * returns all event types, in no particular order.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventTypesOutcome DescribeEventTypes(const Model::DescribeEventTypesRequest& request) const;

        /**
         *
Returns the event types that meet the specified filter criteria. You can use
         * this API operation to find information about the AWS Health event, such as the
         * category, AWS service, and event code. The metadata for each event appears in
         * the EventType
         * object.

If you don't specify a filter criteria, the API operation
         * returns all event types, in no particular order.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns the event types that meet the specified filter criteria. You can use
         * this API operation to find information about the AWS Health event, such as the
         * category, AWS service, and event code. The metadata for each event appears in
         * the EventType
         * object.

If you don't specify a filter criteria, the API operation
         * returns all event types, in no particular order.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
 Returns information about events that meet the specified filter criteria.
         * Events are returned in a summary form and do not include the detailed
         * description, any additional metadata that depends on the event type, or any
         * affected resources. To retrieve that information, use the DescribeEventDetails
         * and DescribeAffectedEntities
         * operations.

If no filter criteria are specified, all events are returned.
         * Results are sorted by lastModifiedTime, starting with the most
         * recent event.

When you call the
         * DescribeEvents operation and specify an entity for the
         * entityValues parameter, AWS Health might return public events that
         * aren't specific to that resource. For example, if you call
         * DescribeEvents and specify an ID for an Amazon Elastic Compute
         * Cloud (Amazon EC2) instance, AWS Health might return events that aren't specific
         * to that resource or service. To get events that are specific to a service, use
         * the services parameter in the filter object. For more
         * information, see Event.

         *

This API operation uses pagination. Specify the
         * nextToken parameter in the next request to return more results.

         *

See Also:
   AWS
         * API Reference

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

        /**
         *
 Returns information about events that meet the specified filter criteria.
         * Events are returned in a summary form and do not include the detailed
         * description, any additional metadata that depends on the event type, or any
         * affected resources. To retrieve that information, use the DescribeEventDetails
         * and DescribeAffectedEntities
         * operations.

If no filter criteria are specified, all events are returned.
         * Results are sorted by lastModifiedTime, starting with the most
         * recent event.

When you call the
         * DescribeEvents operation and specify an entity for the
         * entityValues parameter, AWS Health might return public events that
         * aren't specific to that resource. For example, if you call
         * DescribeEvents and specify an ID for an Amazon Elastic Compute
         * Cloud (Amazon EC2) instance, AWS Health might return events that aren't specific
         * to that resource or service. To get events that are specific to a service, use
         * the services parameter in the filter object. For more
         * information, see Event.

         *

This API operation uses pagination. Specify the
         * nextToken parameter in the next request to return more results.

         *

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 information about events that meet the specified filter criteria.
         * Events are returned in a summary form and do not include the detailed
         * description, any additional metadata that depends on the event type, or any
         * affected resources. To retrieve that information, use the DescribeEventDetails
         * and DescribeAffectedEntities
         * operations.

If no filter criteria are specified, all events are returned.
         * Results are sorted by lastModifiedTime, starting with the most
         * recent event.

When you call the
         * DescribeEvents operation and specify an entity for the
         * entityValues parameter, AWS Health might return public events that
         * aren't specific to that resource. For example, if you call
         * DescribeEvents and specify an ID for an Amazon Elastic Compute
         * Cloud (Amazon EC2) instance, AWS Health might return events that aren't specific
         * to that resource or service. To get events that are specific to a service, use
         * the services parameter in the filter object. For more
         * information, see Event.

         *

This API operation uses pagination. Specify the
         * nextToken parameter in the next request to return more results.

         *

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 information about events across your organization in AWS
         * Organizations. You can use thefilters parameter to specify the
         * events that you want to return. Events are returned in a summary form and don't
         * include the affected accounts, detailed description, any additional metadata
         * that depends on the event type, or any affected resources. To retrieve that
         * information, use the following operations:

 DescribeAffectedAccountsForOrganization
         *

 DescribeEventDetailsForOrganization
         *

 DescribeAffectedEntitiesForOrganization
         *

If you don't specify a filter, the
         * DescribeEventsForOrganizations returns all events across your
         * organization. Results are sorted by lastModifiedTime, starting with
         * the most recent event.

For more information about the different types of
         * AWS Health events, see Event.

         *
Before you can call this operation, you must first enable AWS Health to work
         * with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeEventsForOrganizationOutcome DescribeEventsForOrganization(const Model::DescribeEventsForOrganizationRequest& request) const;

        /**
         *
Returns information about events across your organization in AWS
         * Organizations. You can use thefilters parameter to specify the
         * events that you want to return. Events are returned in a summary form and don't
         * include the affected accounts, detailed description, any additional metadata
         * that depends on the event type, or any affected resources. To retrieve that
         * information, use the following operations:

 DescribeAffectedAccountsForOrganization
         *

 DescribeEventDetailsForOrganization
         *

 DescribeAffectedEntitiesForOrganization
         *

If you don't specify a filter, the
         * DescribeEventsForOrganizations returns all events across your
         * organization. Results are sorted by lastModifiedTime, starting with
         * the most recent event.

For more information about the different types of
         * AWS Health events, see Event.

         *
Before you can call this operation, you must first enable AWS Health to work
         * with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
Returns information about events across your organization in AWS
         * Organizations. You can use thefilters parameter to specify the
         * events that you want to return. Events are returned in a summary form and don't
         * include the affected accounts, detailed description, any additional metadata
         * that depends on the event type, or any affected resources. To retrieve that
         * information, use the following operations:

 DescribeAffectedAccountsForOrganization
         *

 DescribeEventDetailsForOrganization
         *

 DescribeAffectedEntitiesForOrganization
         *

If you don't specify a filter, the
         * DescribeEventsForOrganizations returns all events across your
         * organization. Results are sorted by lastModifiedTime, starting with
         * the most recent event.

For more information about the different types of
         * AWS Health events, see Event.

         *
Before you can call this operation, you must first enable AWS Health to work
         * with AWS Organizations. To do this, call the EnableHealthServiceAccessForOrganization
         * operation from your organization's management account.

This API
         * operation uses pagination. Specify the nextToken parameter in the
         * next request to return more results.

See Also:
   AWS
         * API Reference

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

        /**
         *
This operation provides status information on enabling or disabling AWS
         * Health to work with your organization. To call this operation, you must sign in
         * as an IAM user, assume an IAM role, or sign in as the root user (not
         * recommended) in the organization's management account.

See Also:

         * AWS
         * API Reference

         */
        virtual Model::DescribeHealthServiceStatusForOrganizationOutcome DescribeHealthServiceStatusForOrganization() const;

        /**
         *
This operation provides status information on enabling or disabling AWS
         * Health to work with your organization. To call this operation, you must sign in
         * as an IAM user, assume an IAM role, or sign in as the root user (not
         * recommended) in the organization's management 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::DescribeHealthServiceStatusForOrganizationOutcomeCallable DescribeHealthServiceStatusForOrganizationCallable() const;

        /**
         *
This operation provides status information on enabling or disabling AWS
         * Health to work with your organization. To call this operation, you must sign in
         * as an IAM user, assume an IAM role, or sign in as the root user (not
         * recommended) in the organization's management account.

See Also:

         * AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeHealthServiceStatusForOrganizationAsync(const DescribeHealthServiceStatusForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
        /**
         *
Disables AWS Health from working with AWS Organizations. To call this
         * operation, you must sign in as an AWS Identity and Access Management (IAM) user,
         * assume an IAM role, or sign in as the root user (not recommended) in the
         * organization's management account. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

This operation
         * doesn't remove the service-linked role from the management account in your
         * organization. You must use the IAM console, API, or AWS Command Line Interface
         * (AWS CLI) to remove the service-linked role. For more information, see Deleting
         * a Service-Linked Role in the IAM User Guide.

You can
         * also disable the organizational feature by using the Organizations DisableAWSServiceAccess
         * API operation. After you call this operation, AWS Health stops aggregating
         * events for all other AWS accounts in your organization. If you call the AWS
         * Health API operations for organizational view, AWS Health returns an error. AWS
         * Health continues to aggregate health events for your AWS account.

         *

See Also:
   AWS
         * API Reference

         */
        virtual Model::DisableHealthServiceAccessForOrganizationOutcome DisableHealthServiceAccessForOrganization() const;

        /**
         *
Disables AWS Health from working with AWS Organizations. To call this
         * operation, you must sign in as an AWS Identity and Access Management (IAM) user,
         * assume an IAM role, or sign in as the root user (not recommended) in the
         * organization's management account. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

This operation
         * doesn't remove the service-linked role from the management account in your
         * organization. You must use the IAM console, API, or AWS Command Line Interface
         * (AWS CLI) to remove the service-linked role. For more information, see Deleting
         * a Service-Linked Role in the IAM User Guide.

You can
         * also disable the organizational feature by using the Organizations DisableAWSServiceAccess
         * API operation. After you call this operation, AWS Health stops aggregating
         * events for all other AWS accounts in your organization. If you call the AWS
         * Health API operations for organizational view, AWS Health returns an error. AWS
         * Health continues to aggregate health events for your AWS 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::DisableHealthServiceAccessForOrganizationOutcomeCallable DisableHealthServiceAccessForOrganizationCallable() const;

        /**
         *
Disables AWS Health from working with AWS Organizations. To call this
         * operation, you must sign in as an AWS Identity and Access Management (IAM) user,
         * assume an IAM role, or sign in as the root user (not recommended) in the
         * organization's management account. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

This operation
         * doesn't remove the service-linked role from the management account in your
         * organization. You must use the IAM console, API, or AWS Command Line Interface
         * (AWS CLI) to remove the service-linked role. For more information, see Deleting
         * a Service-Linked Role in the IAM User Guide.

You can
         * also disable the organizational feature by using the Organizations DisableAWSServiceAccess
         * API operation. After you call this operation, AWS Health stops aggregating
         * events for all other AWS accounts in your organization. If you call the AWS
         * Health API operations for organizational view, AWS Health returns an error. AWS
         * Health continues to aggregate health events for your AWS account.

         *

See Also:
   AWS
         * API Reference

         *
         * Queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DisableHealthServiceAccessForOrganizationAsync(const DisableHealthServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
        /**
         *
Enables AWS Health to work with AWS Organizations. You can use the
         * organizational view feature to aggregate events from all AWS accounts in your
         * organization in a centralized location.

This operation also creates a
         * service-linked role for the management account in the organization.

         *
To call this operation, you must meet the following requirements:

         *

You must have a Business or Enterprise Support plan from AWS Support to use the AWS
         * Health API. If you call the AWS Health API from an AWS account that doesn't have
         * a Business or Enterprise Support plan, you receive a
         * SubscriptionRequiredException error.

You must
         * have permission to call this operation from the organization's management
         * account. For example IAM policies, see AWS
         * Health identity-based policy examples.

If you
         * don't have the required support plan, you can instead use the AWS Health console
         * to enable the organizational view feature. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

See
         * Also:
   AWS
         * API Reference

         */
        virtual Model::EnableHealthServiceAccessForOrganizationOutcome EnableHealthServiceAccessForOrganization() const;

        /**
         *
Enables AWS Health to work with AWS Organizations. You can use the
         * organizational view feature to aggregate events from all AWS accounts in your
         * organization in a centralized location.

This operation also creates a
         * service-linked role for the management account in the organization.

         *
To call this operation, you must meet the following requirements:

         *

You must have a Business or Enterprise Support plan from AWS Support to use the AWS
         * Health API. If you call the AWS Health API from an AWS account that doesn't have
         * a Business or Enterprise Support plan, you receive a
         * SubscriptionRequiredException error.

You must
         * have permission to call this operation from the organization's management
         * account. For example IAM policies, see AWS
         * Health identity-based policy examples.

If you
         * don't have the required support plan, you can instead use the AWS Health console
         * to enable the organizational view feature. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

See
         * Also:
   AWS
         * API Reference

         *
         * returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::EnableHealthServiceAccessForOrganizationOutcomeCallable EnableHealthServiceAccessForOrganizationCallable() const;

        /**
         *
Enables AWS Health to work with AWS Organizations. You can use the
         * organizational view feature to aggregate events from all AWS accounts in your
         * organization in a centralized location.

This operation also creates a
         * service-linked role for the management account in the organization.

         *
To call this operation, you must meet the following requirements:

         *

You must have a Business or Enterprise Support plan from AWS Support to use the AWS
         * Health API. If you call the AWS Health API from an AWS account that doesn't have
         * a Business or Enterprise Support plan, you receive a
         * SubscriptionRequiredException error.

You must
         * have permission to call this operation from the organization's management
         * account. For example IAM policies, see AWS
         * Health identity-based policy examples.

If you
         * don't have the required support plan, you can instead use the AWS Health console
         * to enable the organizational view feature. For more information, see Aggregating
         * AWS Health events in the AWS Health User Guide.

See
         * Also:
   AWS
         * API Reference

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

      void OverrideEndpoint(const Aws::String& endpoint);
    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
        void DescribeAffectedAccountsForOrganizationAsyncHelper(const Model::DescribeAffectedAccountsForOrganizationRequest& request, const DescribeAffectedAccountsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeAffectedEntitiesAsyncHelper(const Model::DescribeAffectedEntitiesRequest& request, const DescribeAffectedEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeAffectedEntitiesForOrganizationAsyncHelper(const Model::DescribeAffectedEntitiesForOrganizationRequest& request, const DescribeAffectedEntitiesForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEntityAggregatesAsyncHelper(const Model::DescribeEntityAggregatesRequest& request, const DescribeEntityAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEventAggregatesAsyncHelper(const Model::DescribeEventAggregatesRequest& request, const DescribeEventAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEventDetailsAsyncHelper(const Model::DescribeEventDetailsRequest& request, const DescribeEventDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEventDetailsForOrganizationAsyncHelper(const Model::DescribeEventDetailsForOrganizationRequest& request, const DescribeEventDetailsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeEventTypesAsyncHelper(const Model::DescribeEventTypesRequest& request, const DescribeEventTypesResponseReceivedHandler& 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 DescribeEventsForOrganizationAsyncHelper(const Model::DescribeEventsForOrganizationRequest& request, const DescribeEventsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeHealthServiceStatusForOrganizationAsyncHelper(const DescribeHealthServiceStatusForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DisableHealthServiceAccessForOrganizationAsyncHelper(const DisableHealthServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void EnableHealthServiceAccessForOrganizationAsyncHelper(const EnableHealthServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

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

} // namespace Health
} // namespace Aws


text:
package org.asynchttpclient.providers.grizzly;

import org.asynchttpclient.AsyncHandler;
import org.asynchttpclient.Request;
import org.asynchttpclient.providers.grizzly.bodyhandler.BodyHandler;
import org.asynchttpclient.providers.grizzly.statushandler.StatusHandler;
import org.asynchttpclient.websocket.WebSocket;
import org.glassfish.grizzly.Connection;
import org.glassfish.grizzly.Grizzly;
import org.glassfish.grizzly.attributes.Attribute;
import org.glassfish.grizzly.attributes.AttributeStorage;
import org.glassfish.grizzly.websockets.HandShake;
import org.glassfish.grizzly.websockets.ProtocolHandler;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import static org.asynchttpclient.providers.grizzly.statushandler.StatusHandler.InvocationStatus;

public final class HttpTransactionContext {

    private static final Attribute<HttpTransactionContext> REQUEST_STATE_ATTR =
                Grizzly.DEFAULT_ATTRIBUTE_BUILDER.createAttribute(HttpTransactionContext.class.getName());

    private final AtomicInteger redirectCount = new AtomicInteger(0);

    private final int maxRedirectCount;
    private final boolean redirectsAllowed;
    private final GrizzlyAsyncHttpProvider provider;

    private Request request;
    private String requestUrl;
    private final AsyncHandler handler;
    private BodyHandler bodyHandler;
    private StatusHandler statusHandler;
    private InvocationStatus invocationStatus = InvocationStatus.CONTINUE;
    private GrizzlyResponseStatus responseStatus;
    private GrizzlyResponseFuture future;
    private String lastRedirectURI;
    private final AtomicLong totalBodyWritten = new AtomicLong();
    private AsyncHandler.STATE currentState;

    private String wsRequestURI;
    private boolean isWSRequest;
    private HandShake handshake;
    private ProtocolHandler protocolHandler;
    private WebSocket webSocket;
    private boolean establishingTunnel;

    // -------------------------------------------------------- Constructors

    private HttpTransactionContext(GrizzlyAsyncHttpProvider provider,
                           final GrizzlyResponseFuture future,
                           final Request request,
                           final AsyncHandler handler) {
        this.provider = provider;

        this.future = future;
        this.request = request;
        this.handler = handler;
        redirectsAllowed = this.provider.getClientConfig().isRedirectEnabled();
        maxRedirectCount = this.provider.getClientConfig().getMaxRedirects();
        this.requestUrl = request.getUrl();

    }

    // ---------------------------------------------------------- Public Methods

    public static void set(final AttributeStorage storage,
                           final HttpTransactionContext httpTransactionState) {

        if (httpTransactionState == null) {
            REQUEST_STATE_ATTR.remove(storage);
        } else {
            REQUEST_STATE_ATTR.set(storage, httpTransactionState);
        }

    }

    public static HttpTransactionContext get(final AttributeStorage storage) {

        return REQUEST_STATE_ATTR.get(storage);

    }

    public static HttpTransactionContext create(final GrizzlyAsyncHttpProvider provider,
                                                final GrizzlyResponseFuture future,
                                                final Request request,
                                                final AsyncHandler handler,
                                                final AttributeStorage storage) {
        final HttpTransactionContext context =
                new HttpTransactionContext(provider, future, request, handler);
        set(storage, context);
        return context;
    }

    public void abort(final Throwable t) {
        if (future != null) {
            future.abort(t);
        }
    }

    public AtomicInteger getRedirectCount() {
        return redirectCount;
    }

    public int getMaxRedirectCount() {
        return maxRedirectCount;
    }

    public boolean isRedirectsAllowed() {
        return redirectsAllowed;
    }

    public GrizzlyAsyncHttpProvider getProvider() {
        return provider;
    }

    public Request getRequest() {
        return request;
    }

    public void setRequest(Request request) {
        this.request = request;
    }

    public String getRequestUrl() {
        return requestUrl;
    }

    public void setRequestUrl(String requestUrl) {
        this.requestUrl = requestUrl;
    }

    public AsyncHandler getHandler() {
        return handler;
    }

    public BodyHandler getBodyHandler() {
        return bodyHandler;
    }

    public void setBodyHandler(BodyHandler bodyHandler) {
        this.bodyHandler = bodyHandler;
    }

    public StatusHandler getStatusHandler() {
        return statusHandler;
    }

    public void setStatusHandler(StatusHandler statusHandler) {
        this.statusHandler = statusHandler;
    }

    public InvocationStatus getInvocationStatus() {
        return invocationStatus;
    }

    public void setInvocationStatus(InvocationStatus invocationStatus) {
        this.invocationStatus = invocationStatus;
    }

    public GrizzlyResponseStatus getResponseStatus() {
        return responseStatus;
    }

    public void setResponseStatus(GrizzlyResponseStatus responseStatus) {
        this.responseStatus = responseStatus;
    }

    public GrizzlyResponseFuture getFuture() {
        return future;
    }

    public void setFuture(GrizzlyResponseFuture future) {
        this.future = future;
    }

    public String getLastRedirectURI() {
        return lastRedirectURI;
    }

    public void setLastRedirectURI(String lastRedirectURI) {
        this.lastRedirectURI = lastRedirectURI;
    }

    public AtomicLong getTotalBodyWritten() {
        return totalBodyWritten;
    }

    public AsyncHandler.STATE getCurrentState() {
        return currentState;
    }

    public void setCurrentState(AsyncHandler.STATE currentState) {
        this.currentState = currentState;
    }

    public String getWsRequestURI() {
        return wsRequestURI;
    }

    public void setWsRequestURI(String wsRequestURI) {
        this.wsRequestURI = wsRequestURI;
    }

    public boolean isWSRequest() {
        return isWSRequest;
    }

    public void setWSRequest(boolean WSRequest) {
        isWSRequest = WSRequest;
    }

    public HandShake getHandshake() {
        return handshake;
    }

    public void setHandshake(HandShake handshake) {
        this.handshake = handshake;
    }

    public ProtocolHandler getProtocolHandler() {
        return protocolHandler;
    }

    public void setProtocolHandler(ProtocolHandler protocolHandler) {
        this.protocolHandler = protocolHandler;
    }

    public WebSocket getWebSocket() {
        return webSocket;
    }

    public void setWebSocket(WebSocket webSocket) {
        this.webSocket = webSocket;
    }

    public boolean isEstablishingTunnel() {
        return establishingTunnel;
    }

    public void setEstablishingTunnel(boolean establishingTunnel) {
        this.establishingTunnel = establishingTunnel;
    }

    // ------------------------------------------------- Package Private Methods

    public HttpTransactionContext copy() {
        final HttpTransactionContext newContext =
                new HttpTransactionContext(provider,
                                           future,
                                           request,
                                           handler);
        newContext.invocationStatus = invocationStatus;
        newContext.bodyHandler = bodyHandler;
        newContext.currentState = currentState;
        newContext.statusHandler = statusHandler;
        newContext.lastRedirectURI = lastRedirectURI;
        newContext.redirectCount.set(redirectCount.get());
        return newContext;

    }

    void done() {
        if (future != null) {
            future.done();
        }
    }

    @SuppressWarnings({"unchecked"})
    void result(Object result) {
        if (future != null) {
            future.delegate.result(result);
            future.done();
        }
    }

    public boolean isTunnelEstablished(final Connection c) {
        return c.getAttributes().getAttribute("tunnel-established") != null;
    }

    public void tunnelEstablished(final Connection c) {
        c.getAttributes().setAttribute("tunnel-established", Boolean.TRUE);
    }

}

redpajama_set_name: RedPajamaGithub


text:
package com.adobe.acs.commons.mcp.form;

import org.osgi.annotation.versioning.ProviderType;

/**
 * Generates a text area component
 */
@ProviderType
public final class TextareaComponent extends TextfieldComponent {

    public TextareaComponent() {
        super();
        setResourceType("granite/ui/components/coral/foundation/form/textarea");
    }
}


text:
// Copyright 2022 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.password_manager;

import com.google.android.gms.common.api.ApiException;

import org.chromium.base.annotations.CalledByNative;
import org.chromium.base.annotations.NativeMethods;
import org.chromium.chrome.browser.sync.SyncService;
import org.chromium.components.signin.base.CoreAccountInfo;

/**
 * Java-counterpart of the native PasswordSyncControllerDelegateBridgeImpl. It's part of
 * PasswordSyncControllerDelegate that propagates sync events to a downstream implementation.
 */
class PasswordSyncControllerDelegateBridgeImpl {
    private final PasswordSyncControllerDelegate mPasswordSyncControllerDelegate;
    private long mNativeDelegateBridgeImpl;

    PasswordSyncControllerDelegateBridgeImpl(long nativePasswordSyncControllerDelegateBridgeImpl,
            PasswordSyncControllerDelegate syncDelegate) {
        mNativeDelegateBridgeImpl = nativePasswordSyncControllerDelegateBridgeImpl;
        assert syncDelegate != null;
        mPasswordSyncControllerDelegate = syncDelegate;
    }

    @CalledByNative
    static PasswordSyncControllerDelegateBridgeImpl create(
            long nativePasswordSyncControllerDelegateBridgeImpl) {
        PasswordSyncControllerDelegateFactory factory =
                new PasswordSyncControllerDelegateFactoryImpl();
        return new PasswordSyncControllerDelegateBridgeImpl(
                nativePasswordSyncControllerDelegateBridgeImpl, factory.createDelegate());
    }

    /**
     * Notifies credential manager of the currently syncing account.
     */
    @CalledByNative
    void notifyCredentialManagerWhenSyncing() {
        mPasswordSyncControllerDelegate.notifyCredentialManagerWhenSyncing(
                CoreAccountInfo.getEmailFrom(SyncService.get().getAccountInfo()), () -> {
                    if (mNativeDelegateBridgeImpl == 0) return;
                    PasswordSyncControllerDelegateBridgeImplJni.get().onCredentialManagerNotified(
                            mNativeDelegateBridgeImpl);
                }, exception -> handleCredentialManagerException(exception));
    }

    /**
     * Notifies credential manager of a local account, when not syncing.
     */
    @CalledByNative
    void notifyCredentialManagerWhenNotSyncing() {
        mPasswordSyncControllerDelegate.notifyCredentialManagerWhenNotSyncing(() -> {
            if (mNativeDelegateBridgeImpl == 0) return;
            PasswordSyncControllerDelegateBridgeImplJni.get().onCredentialManagerNotified(
                    mNativeDelegateBridgeImpl);
        }, exception -> handleCredentialManagerException(exception));
    }

    /**
     * Handles exceptions occurring in downstream implementation.
     *
     * @param exception PasswordStoreAndroidBackend or API exception.
     */
    private void handleCredentialManagerException(Exception exception) {
        if (mNativeDelegateBridgeImpl == 0) return;

        @AndroidBackendErrorType
        int error = AndroidBackendErrorType.UNCATEGORIZED;
        int apiErrorCode = 0; // '0' means SUCCESS.

        if (exception instanceof PasswordStoreAndroidBackend.BackendException) {
            error = ((PasswordStoreAndroidBackend.BackendException) exception).errorCode;
        }

        if (exception instanceof ApiException) {
            error = AndroidBackendErrorType.EXTERNAL_ERROR;
            apiErrorCode = ((ApiException) exception).getStatusCode();
        }

        PasswordSyncControllerDelegateBridgeImplJni.get().onCredentialManagerError(
                mNativeDelegateBridgeImpl, error, apiErrorCode);
    }

    /**
     * C++ method signatures.
     */
    @NativeMethods
    interface Natives {
        void onCredentialManagerNotified(long nativePasswordSyncControllerDelegateBridgeImpl);
        void onCredentialManagerError(long nativePasswordSyncControllerDelegateBridgeImpl,
                int errorType, int apiErrorCode);
    }
}


text:
/* Generated by Snowball 2.2.0 - https://snowballstem.org/ */

#ifdef __cplusplus
extern "C" {
#endif

extern struct SN_env * armenian_UTF_8_create_env(void);
extern void armenian_UTF_8_close_env(struct SN_env * z);

extern int armenian_UTF_8_stem(struct SN_env * z);

#ifdef __cplusplus
}
#endif


text:
<?php

// DUDEEGOPlatformBundle:back:logementThree.html.twig
return array (
);


text:
namespace XenAdmin.Wizards.NewPolicyWizard
{
    partial class NewPolicyFinishPage
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(NewPolicyFinishPage));
            this.label13 = new System.Windows.Forms.Label();
            this.textBoxSummary = new System.Windows.Forms.TextBox();
            this.checkBox1 = new System.Windows.Forms.CheckBox();
            this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
            this.tableLayoutPanel1.SuspendLayout();
            this.SuspendLayout();
            //
            // label13
            //
            resources.ApplyResources(this.label13, "label13");
            this.label13.Name = "label13";
            //
            // textBoxSummary
            //
            resources.ApplyResources(this.textBoxSummary, "textBoxSummary");
            this.textBoxSummary.Name = "textBoxSummary";
            this.textBoxSummary.ReadOnly = true;
            this.textBoxSummary.TabStop = false;
            //
            // checkBox1
            //
            resources.ApplyResources(this.checkBox1, "checkBox1");
            this.checkBox1.Name = "checkBox1";
            this.checkBox1.UseVisualStyleBackColor = true;
            //
            // tableLayoutPanel1
            //
            resources.ApplyResources(this.tableLayoutPanel1, "tableLayoutPanel1");
            this.tableLayoutPanel1.Controls.Add(this.checkBox1, 0, 2);
            this.tableLayoutPanel1.Controls.Add(this.label13, 0, 0);
            this.tableLayoutPanel1.Controls.Add(this.textBoxSummary, 0, 1);
            this.tableLayoutPanel1.Name = "tableLayoutPanel1";
            //
            // NewPolicyFinishPage
            //
            resources.ApplyResources(this, "$this");
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
            this.Controls.Add(this.tableLayoutPanel1);
            this.Name = "NewPolicyFinishPage";
            this.tableLayoutPanel1.ResumeLayout(false);
            this.tableLayoutPanel1.PerformLayout();
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.Label label13;
        private System.Windows.Forms.TextBox textBoxSummary;
        private System.Windows.Forms.CheckBox checkBox1;
        private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
    }
}


text:
require 'resque/server'
require 'resque-retry'
require 'resque-sentry'
require 'resque/failure/redis'

if ENV["REDISTOGO_URL"]
  Resque.redis = Redis.new(url: ENV["REDISTOGO_URL"], thread_safe: true)
end

Resque::Server.use(Rack::Auth::Basic) do |user, password|
  [user, password].join(':') == ENV['BASIC_AUTH']
end

Resque::Failure::Sentry.logger = 'resque'

Resque::Failure::MultipleWithRetrySuppression.classes = [
  Resque::Failure::Redis,
  Resque::Failure::Sentry
]
Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression


text:
package org.elasticsearch.bootstrap;

/**
 * Exposes system startup information
 */
public final class BootstrapInfo {

    /** no instantiation */
    private BootstrapInfo() {}

    /**
     * Returns true if we successfully loaded native libraries.
     *

     * If this returns false, then native operations such as locking
     * memory did not work.
     */
    public static boolean isNativesAvailable() {
        return Natives.JNA_AVAILABLE;
    }

    /**
     * Returns true if we were able to lock the process's address space.
     */
    public static boolean isMemoryLocked() {
        return Natives.isMemoryLocked();
    }

    /**
     * Returns true if secure computing mode is enabled (linux/amd64, OS X only)
     */
    public static boolean isSeccompInstalled() {
        return Natives.isSeccompInstalled();
    }

    /**
     * codebase location for untrusted scripts (provide some additional safety)
     *

     * This is not a full URL, just a path.
     */
    public static final String UNTRUSTED_CODEBASE = "/untrusted";
}