text:
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var path_1 = require("./path");
var leaflet_1 = require("leaflet");
var underscore_1 = require("underscore");
var GeoJSONLayer = (function (_super) {
    __extends(GeoJSONLayer, _super);
    function GeoJSONLayer() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    GeoJSONLayer.prototype.initLeafletElement = function () {
        this.leafletElement = new leaflet_1.GeoJSON(this.props.geojson, path_1.Path.createLeafletOptions(underscore_1.omit(this.props, "geojson")));
    };
    GeoJSONLayer.prototype.render = function () {
        return null;
    };
    return GeoJSONLayer;
}(path_1.Path));
exports.GeoJSONLayer = GeoJSONLayer;
//# sourceMappingURL=geo-json-layer.js.map


text:
/*
 * Do not modify this file. This file is generated from the elasticbeanstalk-2010-12-01.normal.json service model.
 */

using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;

using Amazon.ElasticBeanstalk.Model;
using Amazon.ElasticBeanstalk.Model.Internal.MarshallTransformations;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;

namespace Amazon.ElasticBeanstalk
{
    ///
    /// Implementation for accessing ElasticBeanstalk
    ///
    /// AWS Elastic Beanstalk
    /// <para>
    ///  This is the AWS Elastic Beanstalk API Reference. This guide provides detailed information
    /// about AWS Elastic Beanstalk actions, data types, parameters, and errors.
    /// </para>
    ///
    /// <para>
    /// AWS Elastic Beanstalk is a tool that makes it easy for you to create, deploy, and
    /// manage scalable, fault-tolerant applications running on Amazon Web Services cloud
    /// resources.
    /// </para>
    ///
    /// <para>
    ///  For more information about this product, go to the AWS
    /// Elastic Beanstalk details page. The location of the latest AWS Elastic Beanstalk
    /// WSDL is http://elasticbeanstalk.s3.amazonaws.com/doc/2010-12-01/AWSElasticBeanstalk.wsdl.
    /// To install the Software Development Kits (SDKs), Integrated Development Environment
    /// (IDE) Toolkits, and command line tools that enable you to access the API, go to Tools for Amazon Web Services.
    /// </para>
    ///
    /// <para>
    /// Endpoints
    /// </para>
    ///
    /// <para>
    /// For a list of region-specific endpoints that AWS Elastic Beanstalk supports, go to
    /// Regions
    /// and Endpoints in the Amazon Web Services Glossary.
    /// </para>
    ///
    public partial class AmazonElasticBeanstalkClient : AmazonServiceClient, IAmazonElasticBeanstalk
    {

        #region Constructors

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Credentials
        ///
        /// <param name="credentials">AWS Credentials</param>
        public AmazonElasticBeanstalkClient(AWSCredentials credentials)
            : this(credentials, new AmazonElasticBeanstalkConfig())
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Credentials
        ///
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="region">The region to connect.</param>
        public AmazonElasticBeanstalkClient(AWSCredentials credentials, RegionEndpoint region)
            : this(credentials, new AmazonElasticBeanstalkConfig{RegionEndpoint = region})
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Credentials and an
        /// AmazonElasticBeanstalkClient Configuration object.
        ///
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="clientConfig">The AmazonElasticBeanstalkClient Configuration Object</param>
        public AmazonElasticBeanstalkClient(AWSCredentials credentials, AmazonElasticBeanstalkConfig clientConfig)
            : base(credentials, clientConfig)
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticBeanstalkConfig())
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="region">The region to connect.</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticBeanstalkConfig() {RegionEndpoint=region})
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonElasticBeanstalkClient Configuration object.
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="clientConfig">The AmazonElasticBeanstalkClient Configuration Object</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonElasticBeanstalkConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticBeanstalkConfig())
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID and AWS Secret Key
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="region">The region to connect.</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticBeanstalkConfig{RegionEndpoint = region})
        {
        }

        ///
        /// Constructs AmazonElasticBeanstalkClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonElasticBeanstalkClient Configuration object.
        ///
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="clientConfig">The AmazonElasticBeanstalkClient Configuration Object</param>
        public AmazonElasticBeanstalkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonElasticBeanstalkConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
        {
        }

        #endregion

        #region Overrides

        ///
        /// Creates the signer for the service.
        ///
        protected override AbstractAWSSigner CreateSigner()
        {
            return new AWS4Signer();
        }

        #endregion

        #region Dispose

        ///
        /// Disposes the service client.
        ///
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        #endregion

        #region  AbortEnvironmentUpdate

        internal AbortEnvironmentUpdateResponse AbortEnvironmentUpdate(AbortEnvironmentUpdateRequest request)
        {
            var marshaller = new AbortEnvironmentUpdateRequestMarshaller();
            var unmarshaller = AbortEnvironmentUpdateResponseUnmarshaller.Instance;

            return Invoke<AbortEnvironmentUpdateRequest,AbortEnvironmentUpdateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the AbortEnvironmentUpdate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the AbortEnvironmentUpdate operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<AbortEnvironmentUpdateResponse> AbortEnvironmentUpdateAsync(AbortEnvironmentUpdateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new AbortEnvironmentUpdateRequestMarshaller();
            var unmarshaller = AbortEnvironmentUpdateResponseUnmarshaller.Instance;

            return InvokeAsync<AbortEnvironmentUpdateRequest,AbortEnvironmentUpdateResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CheckDNSAvailability

        internal CheckDNSAvailabilityResponse CheckDNSAvailability(CheckDNSAvailabilityRequest request)
        {
            var marshaller = new CheckDNSAvailabilityRequestMarshaller();
            var unmarshaller = CheckDNSAvailabilityResponseUnmarshaller.Instance;

            return Invoke<CheckDNSAvailabilityRequest,CheckDNSAvailabilityResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CheckDNSAvailability operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CheckDNSAvailability operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CheckDNSAvailabilityResponse> CheckDNSAvailabilityAsync(CheckDNSAvailabilityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CheckDNSAvailabilityRequestMarshaller();
            var unmarshaller = CheckDNSAvailabilityResponseUnmarshaller.Instance;

            return InvokeAsync<CheckDNSAvailabilityRequest,CheckDNSAvailabilityResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateApplication

        internal CreateApplicationResponse CreateApplication(CreateApplicationRequest request)
        {
            var marshaller = new CreateApplicationRequestMarshaller();
            var unmarshaller = CreateApplicationResponseUnmarshaller.Instance;

            return Invoke<CreateApplicationRequest,CreateApplicationResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateApplication operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateApplication operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateApplicationResponse> CreateApplicationAsync(CreateApplicationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateApplicationRequestMarshaller();
            var unmarshaller = CreateApplicationResponseUnmarshaller.Instance;

            return InvokeAsync<CreateApplicationRequest,CreateApplicationResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateApplicationVersion

        internal CreateApplicationVersionResponse CreateApplicationVersion(CreateApplicationVersionRequest request)
        {
            var marshaller = new CreateApplicationVersionRequestMarshaller();
            var unmarshaller = CreateApplicationVersionResponseUnmarshaller.Instance;

            return Invoke<CreateApplicationVersionRequest,CreateApplicationVersionResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateApplicationVersion operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateApplicationVersion operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateApplicationVersionResponse> CreateApplicationVersionAsync(CreateApplicationVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateApplicationVersionRequestMarshaller();
            var unmarshaller = CreateApplicationVersionResponseUnmarshaller.Instance;

            return InvokeAsync<CreateApplicationVersionRequest,CreateApplicationVersionResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateConfigurationTemplate

        internal CreateConfigurationTemplateResponse CreateConfigurationTemplate(CreateConfigurationTemplateRequest request)
        {
            var marshaller = new CreateConfigurationTemplateRequestMarshaller();
            var unmarshaller = CreateConfigurationTemplateResponseUnmarshaller.Instance;

            return Invoke<CreateConfigurationTemplateRequest,CreateConfigurationTemplateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateConfigurationTemplate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateConfigurationTemplate operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateConfigurationTemplateResponse> CreateConfigurationTemplateAsync(CreateConfigurationTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateConfigurationTemplateRequestMarshaller();
            var unmarshaller = CreateConfigurationTemplateResponseUnmarshaller.Instance;

            return InvokeAsync<CreateConfigurationTemplateRequest,CreateConfigurationTemplateResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateEnvironment

        internal CreateEnvironmentResponse CreateEnvironment(CreateEnvironmentRequest request)
        {
            var marshaller = new CreateEnvironmentRequestMarshaller();
            var unmarshaller = CreateEnvironmentResponseUnmarshaller.Instance;

            return Invoke<CreateEnvironmentRequest,CreateEnvironmentResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateEnvironment operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateEnvironment operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateEnvironmentResponse> CreateEnvironmentAsync(CreateEnvironmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateEnvironmentRequestMarshaller();
            var unmarshaller = CreateEnvironmentResponseUnmarshaller.Instance;

            return InvokeAsync<CreateEnvironmentRequest,CreateEnvironmentResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  CreateStorageLocation

        internal CreateStorageLocationResponse CreateStorageLocation()
        {
            return CreateStorageLocation(new CreateStorageLocationRequest());
        }
        internal CreateStorageLocationResponse CreateStorageLocation(CreateStorageLocationRequest request)
        {
            var marshaller = new CreateStorageLocationRequestMarshaller();
            var unmarshaller = CreateStorageLocationResponseUnmarshaller.Instance;

            return Invoke<CreateStorageLocationRequest,CreateStorageLocationResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Creates the Amazon S3 storage location for the account.
        ///
        ///
        /// <para>
        ///  This location is used to store user log files.
        /// </para>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the CreateStorageLocation service method, as returned by ElasticBeanstalk.</returns>
        /// <exception cref="Amazon.ElasticBeanstalk.Model.InsufficientPrivilegesException">
        /// Unable to perform the specified operation because the user does not have enough privileges
        /// for one of more downstream aws services
        /// </exception>
        /// <exception cref="Amazon.ElasticBeanstalk.Model.S3SubscriptionRequiredException">
        /// The caller does not have a subscription to Amazon S3.
        /// </exception>
        /// <exception cref="Amazon.ElasticBeanstalk.Model.TooManyBucketsException">
        /// The web service attempted to create a bucket in an Amazon S3 account that already
        /// has 100 buckets.
        /// </exception>
        public Task<CreateStorageLocationResponse> CreateStorageLocationAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return CreateStorageLocationAsync(new CreateStorageLocationRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the CreateStorageLocation operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateStorageLocation operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<CreateStorageLocationResponse> CreateStorageLocationAsync(CreateStorageLocationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new CreateStorageLocationRequestMarshaller();
            var unmarshaller = CreateStorageLocationResponseUnmarshaller.Instance;

            return InvokeAsync<CreateStorageLocationRequest,CreateStorageLocationResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteApplication

        internal DeleteApplicationResponse DeleteApplication(DeleteApplicationRequest request)
        {
            var marshaller = new DeleteApplicationRequestMarshaller();
            var unmarshaller = DeleteApplicationResponseUnmarshaller.Instance;

            return Invoke<DeleteApplicationRequest,DeleteApplicationResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteApplication operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteApplication operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteApplicationResponse> DeleteApplicationAsync(DeleteApplicationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteApplicationRequestMarshaller();
            var unmarshaller = DeleteApplicationResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteApplicationRequest,DeleteApplicationResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteApplicationVersion

        internal DeleteApplicationVersionResponse DeleteApplicationVersion(DeleteApplicationVersionRequest request)
        {
            var marshaller = new DeleteApplicationVersionRequestMarshaller();
            var unmarshaller = DeleteApplicationVersionResponseUnmarshaller.Instance;

            return Invoke<DeleteApplicationVersionRequest,DeleteApplicationVersionResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteApplicationVersion operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteApplicationVersion operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteApplicationVersionResponse> DeleteApplicationVersionAsync(DeleteApplicationVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteApplicationVersionRequestMarshaller();
            var unmarshaller = DeleteApplicationVersionResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteApplicationVersionRequest,DeleteApplicationVersionResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteConfigurationTemplate

        internal DeleteConfigurationTemplateResponse DeleteConfigurationTemplate(DeleteConfigurationTemplateRequest request)
        {
            var marshaller = new DeleteConfigurationTemplateRequestMarshaller();
            var unmarshaller = DeleteConfigurationTemplateResponseUnmarshaller.Instance;

            return Invoke<DeleteConfigurationTemplateRequest,DeleteConfigurationTemplateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteConfigurationTemplate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteConfigurationTemplate operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteConfigurationTemplateResponse> DeleteConfigurationTemplateAsync(DeleteConfigurationTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteConfigurationTemplateRequestMarshaller();
            var unmarshaller = DeleteConfigurationTemplateResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteConfigurationTemplateRequest,DeleteConfigurationTemplateResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DeleteEnvironmentConfiguration

        internal DeleteEnvironmentConfigurationResponse DeleteEnvironmentConfiguration(DeleteEnvironmentConfigurationRequest request)
        {
            var marshaller = new DeleteEnvironmentConfigurationRequestMarshaller();
            var unmarshaller = DeleteEnvironmentConfigurationResponseUnmarshaller.Instance;

            return Invoke<DeleteEnvironmentConfigurationRequest,DeleteEnvironmentConfigurationResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteEnvironmentConfiguration operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteEnvironmentConfiguration operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DeleteEnvironmentConfigurationResponse> DeleteEnvironmentConfigurationAsync(DeleteEnvironmentConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DeleteEnvironmentConfigurationRequestMarshaller();
            var unmarshaller = DeleteEnvironmentConfigurationResponseUnmarshaller.Instance;

            return InvokeAsync<DeleteEnvironmentConfigurationRequest,DeleteEnvironmentConfigurationResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeApplications

        internal DescribeApplicationsResponse DescribeApplications()
        {
            return DescribeApplications(new DescribeApplicationsRequest());
        }
        internal DescribeApplicationsResponse DescribeApplications(DescribeApplicationsRequest request)
        {
            var marshaller = new DescribeApplicationsRequestMarshaller();
            var unmarshaller = DescribeApplicationsResponseUnmarshaller.Instance;

            return Invoke<DescribeApplicationsRequest,DescribeApplicationsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns the descriptions of existing applications.
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the DescribeApplications service method, as returned by ElasticBeanstalk.</returns>
        public Task<DescribeApplicationsResponse> DescribeApplicationsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return DescribeApplicationsAsync(new DescribeApplicationsRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeApplications operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeApplications operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeApplicationsResponse> DescribeApplicationsAsync(DescribeApplicationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeApplicationsRequestMarshaller();
            var unmarshaller = DescribeApplicationsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeApplicationsRequest,DescribeApplicationsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeApplicationVersions

        internal DescribeApplicationVersionsResponse DescribeApplicationVersions()
        {
            return DescribeApplicationVersions(new DescribeApplicationVersionsRequest());
        }
        internal DescribeApplicationVersionsResponse DescribeApplicationVersions(DescribeApplicationVersionsRequest request)
        {
            var marshaller = new DescribeApplicationVersionsRequestMarshaller();
            var unmarshaller = DescribeApplicationVersionsResponseUnmarshaller.Instance;

            return Invoke<DescribeApplicationVersionsRequest,DescribeApplicationVersionsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns descriptions for existing application versions.
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the DescribeApplicationVersions service method, as returned by ElasticBeanstalk.</returns>
        public Task<DescribeApplicationVersionsResponse> DescribeApplicationVersionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return DescribeApplicationVersionsAsync(new DescribeApplicationVersionsRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeApplicationVersions operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeApplicationVersions operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeApplicationVersionsResponse> DescribeApplicationVersionsAsync(DescribeApplicationVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeApplicationVersionsRequestMarshaller();
            var unmarshaller = DescribeApplicationVersionsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeApplicationVersionsRequest,DescribeApplicationVersionsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeConfigurationOptions

        internal DescribeConfigurationOptionsResponse DescribeConfigurationOptions()
        {
            return DescribeConfigurationOptions(new DescribeConfigurationOptionsRequest());
        }
        internal DescribeConfigurationOptionsResponse DescribeConfigurationOptions(DescribeConfigurationOptionsRequest request)
        {
            var marshaller = new DescribeConfigurationOptionsRequestMarshaller();
            var unmarshaller = DescribeConfigurationOptionsResponseUnmarshaller.Instance;

            return Invoke<DescribeConfigurationOptionsRequest,DescribeConfigurationOptionsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Describes the configuration options that are used in a particular configuration template
        /// or environment, or that a specified solution stack defines. The description includes
        /// the values the options, their default values, and an indication of the required action
        /// on a running environment if an option value is changed.
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the DescribeConfigurationOptions service method, as returned by ElasticBeanstalk.</returns>
        public Task<DescribeConfigurationOptionsResponse> DescribeConfigurationOptionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return DescribeConfigurationOptionsAsync(new DescribeConfigurationOptionsRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeConfigurationOptions operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeConfigurationOptions operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeConfigurationOptionsResponse> DescribeConfigurationOptionsAsync(DescribeConfigurationOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeConfigurationOptionsRequestMarshaller();
            var unmarshaller = DescribeConfigurationOptionsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeConfigurationOptionsRequest,DescribeConfigurationOptionsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeConfigurationSettings

        internal DescribeConfigurationSettingsResponse DescribeConfigurationSettings(DescribeConfigurationSettingsRequest request)
        {
            var marshaller = new DescribeConfigurationSettingsRequestMarshaller();
            var unmarshaller = DescribeConfigurationSettingsResponseUnmarshaller.Instance;

            return Invoke<DescribeConfigurationSettingsRequest,DescribeConfigurationSettingsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeConfigurationSettings operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeConfigurationSettings operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeConfigurationSettingsResponse> DescribeConfigurationSettingsAsync(DescribeConfigurationSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeConfigurationSettingsRequestMarshaller();
            var unmarshaller = DescribeConfigurationSettingsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeConfigurationSettingsRequest,DescribeConfigurationSettingsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeEnvironmentHealth

        internal DescribeEnvironmentHealthResponse DescribeEnvironmentHealth(DescribeEnvironmentHealthRequest request)
        {
            var marshaller = new DescribeEnvironmentHealthRequestMarshaller();
            var unmarshaller = DescribeEnvironmentHealthResponseUnmarshaller.Instance;

            return Invoke<DescribeEnvironmentHealthRequest,DescribeEnvironmentHealthResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeEnvironmentHealth operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeEnvironmentHealth operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeEnvironmentHealthResponse> DescribeEnvironmentHealthAsync(DescribeEnvironmentHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeEnvironmentHealthRequestMarshaller();
            var unmarshaller = DescribeEnvironmentHealthResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeEnvironmentHealthRequest,DescribeEnvironmentHealthResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeEnvironmentResources

        internal DescribeEnvironmentResourcesResponse DescribeEnvironmentResources(DescribeEnvironmentResourcesRequest request)
        {
            var marshaller = new DescribeEnvironmentResourcesRequestMarshaller();
            var unmarshaller = DescribeEnvironmentResourcesResponseUnmarshaller.Instance;

            return Invoke<DescribeEnvironmentResourcesRequest,DescribeEnvironmentResourcesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeEnvironmentResources operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeEnvironmentResources operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeEnvironmentResourcesResponse> DescribeEnvironmentResourcesAsync(DescribeEnvironmentResourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeEnvironmentResourcesRequestMarshaller();
            var unmarshaller = DescribeEnvironmentResourcesResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeEnvironmentResourcesRequest,DescribeEnvironmentResourcesResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeEnvironments

        internal DescribeEnvironmentsResponse DescribeEnvironments()
        {
            return DescribeEnvironments(new DescribeEnvironmentsRequest());
        }
        internal DescribeEnvironmentsResponse DescribeEnvironments(DescribeEnvironmentsRequest request)
        {
            var marshaller = new DescribeEnvironmentsRequestMarshaller();
            var unmarshaller = DescribeEnvironmentsResponseUnmarshaller.Instance;

            return Invoke<DescribeEnvironmentsRequest,DescribeEnvironmentsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns descriptions for existing environments.
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the DescribeEnvironments service method, as returned by ElasticBeanstalk.</returns>
        public Task<DescribeEnvironmentsResponse> DescribeEnvironmentsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return DescribeEnvironmentsAsync(new DescribeEnvironmentsRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeEnvironments operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeEnvironments operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeEnvironmentsResponse> DescribeEnvironmentsAsync(DescribeEnvironmentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeEnvironmentsRequestMarshaller();
            var unmarshaller = DescribeEnvironmentsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeEnvironmentsRequest,DescribeEnvironmentsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeEvents

        internal DescribeEventsResponse DescribeEvents()
        {
            return DescribeEvents(new DescribeEventsRequest());
        }
        internal DescribeEventsResponse DescribeEvents(DescribeEventsRequest request)
        {
            var marshaller = new DescribeEventsRequestMarshaller();
            var unmarshaller = DescribeEventsResponseUnmarshaller.Instance;

            return Invoke<DescribeEventsRequest,DescribeEventsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns list of event descriptions matching criteria up to the last 6 weeks.
        ///
        ///  <note> This action returns the most recent 1,000 events from the specified NextToken.
        /// </note>
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the DescribeEvents service method, as returned by ElasticBeanstalk.</returns>
        public Task<DescribeEventsResponse> DescribeEventsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return DescribeEventsAsync(new DescribeEventsRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeEvents operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeEvents operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeEventsResponse> DescribeEventsAsync(DescribeEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeEventsRequestMarshaller();
            var unmarshaller = DescribeEventsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeEventsRequest,DescribeEventsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  DescribeInstancesHealth

        internal DescribeInstancesHealthResponse DescribeInstancesHealth(DescribeInstancesHealthRequest request)
        {
            var marshaller = new DescribeInstancesHealthRequestMarshaller();
            var unmarshaller = DescribeInstancesHealthResponseUnmarshaller.Instance;

            return Invoke<DescribeInstancesHealthRequest,DescribeInstancesHealthResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeInstancesHealth operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstancesHealth operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<DescribeInstancesHealthResponse> DescribeInstancesHealthAsync(DescribeInstancesHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeInstancesHealthRequestMarshaller();
            var unmarshaller = DescribeInstancesHealthResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeInstancesHealthRequest,DescribeInstancesHealthResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ListAvailableSolutionStacks

        internal ListAvailableSolutionStacksResponse ListAvailableSolutionStacks()
        {
            return ListAvailableSolutionStacks(new ListAvailableSolutionStacksRequest());
        }
        internal ListAvailableSolutionStacksResponse ListAvailableSolutionStacks(ListAvailableSolutionStacksRequest request)
        {
            var marshaller = new ListAvailableSolutionStacksRequestMarshaller();
            var unmarshaller = ListAvailableSolutionStacksResponseUnmarshaller.Instance;

            return Invoke<ListAvailableSolutionStacksRequest,ListAvailableSolutionStacksResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Returns a list of the available solution stack names.
        ///
        /// <param name="cancellationToken"> ttd1
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        ///
        /// <returns>The response from the ListAvailableSolutionStacks service method, as returned by ElasticBeanstalk.</returns>
        public Task<ListAvailableSolutionStacksResponse> ListAvailableSolutionStacksAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            return ListAvailableSolutionStacksAsync(new ListAvailableSolutionStacksRequest(), cancellationToken);
        }

        ///
        /// Initiates the asynchronous execution of the ListAvailableSolutionStacks operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListAvailableSolutionStacks operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ListAvailableSolutionStacksResponse> ListAvailableSolutionStacksAsync(ListAvailableSolutionStacksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListAvailableSolutionStacksRequestMarshaller();
            var unmarshaller = ListAvailableSolutionStacksResponseUnmarshaller.Instance;

            return InvokeAsync<ListAvailableSolutionStacksRequest,ListAvailableSolutionStacksResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  RebuildEnvironment

        internal RebuildEnvironmentResponse RebuildEnvironment(RebuildEnvironmentRequest request)
        {
            var marshaller = new RebuildEnvironmentRequestMarshaller();
            var unmarshaller = RebuildEnvironmentResponseUnmarshaller.Instance;

            return Invoke<RebuildEnvironmentRequest,RebuildEnvironmentResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the RebuildEnvironment operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the RebuildEnvironment operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<RebuildEnvironmentResponse> RebuildEnvironmentAsync(RebuildEnvironmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new RebuildEnvironmentRequestMarshaller();
            var unmarshaller = RebuildEnvironmentResponseUnmarshaller.Instance;

            return InvokeAsync<RebuildEnvironmentRequest,RebuildEnvironmentResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  RequestEnvironmentInfo

        internal RequestEnvironmentInfoResponse RequestEnvironmentInfo(RequestEnvironmentInfoRequest request)
        {
            var marshaller = new RequestEnvironmentInfoRequestMarshaller();
            var unmarshaller = RequestEnvironmentInfoResponseUnmarshaller.Instance;

            return Invoke<RequestEnvironmentInfoRequest,RequestEnvironmentInfoResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the RequestEnvironmentInfo operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the RequestEnvironmentInfo operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<RequestEnvironmentInfoResponse> RequestEnvironmentInfoAsync(RequestEnvironmentInfoRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new RequestEnvironmentInfoRequestMarshaller();
            var unmarshaller = RequestEnvironmentInfoResponseUnmarshaller.Instance;

            return InvokeAsync<RequestEnvironmentInfoRequest,RequestEnvironmentInfoResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  RestartAppServer

        internal RestartAppServerResponse RestartAppServer(RestartAppServerRequest request)
        {
            var marshaller = new RestartAppServerRequestMarshaller();
            var unmarshaller = RestartAppServerResponseUnmarshaller.Instance;

            return Invoke<RestartAppServerRequest,RestartAppServerResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the RestartAppServer operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the RestartAppServer operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<RestartAppServerResponse> RestartAppServerAsync(RestartAppServerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new RestartAppServerRequestMarshaller();
            var unmarshaller = RestartAppServerResponseUnmarshaller.Instance;

            return InvokeAsync<RestartAppServerRequest,RestartAppServerResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  RetrieveEnvironmentInfo

        internal RetrieveEnvironmentInfoResponse RetrieveEnvironmentInfo(RetrieveEnvironmentInfoRequest request)
        {
            var marshaller = new RetrieveEnvironmentInfoRequestMarshaller();
            var unmarshaller = RetrieveEnvironmentInfoResponseUnmarshaller.Instance;

            return Invoke<RetrieveEnvironmentInfoRequest,RetrieveEnvironmentInfoResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the RetrieveEnvironmentInfo operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the RetrieveEnvironmentInfo operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<RetrieveEnvironmentInfoResponse> RetrieveEnvironmentInfoAsync(RetrieveEnvironmentInfoRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new RetrieveEnvironmentInfoRequestMarshaller();
            var unmarshaller = RetrieveEnvironmentInfoResponseUnmarshaller.Instance;

            return InvokeAsync<RetrieveEnvironmentInfoRequest,RetrieveEnvironmentInfoResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  SwapEnvironmentCNAMEs

        internal SwapEnvironmentCNAMEsResponse SwapEnvironmentCNAMEs(SwapEnvironmentCNAMEsRequest request)
        {
            var marshaller = new SwapEnvironmentCNAMEsRequestMarshaller();
            var unmarshaller = SwapEnvironmentCNAMEsResponseUnmarshaller.Instance;

            return Invoke<SwapEnvironmentCNAMEsRequest,SwapEnvironmentCNAMEsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SwapEnvironmentCNAMEs operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SwapEnvironmentCNAMEs operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<SwapEnvironmentCNAMEsResponse> SwapEnvironmentCNAMEsAsync(SwapEnvironmentCNAMEsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new SwapEnvironmentCNAMEsRequestMarshaller();
            var unmarshaller = SwapEnvironmentCNAMEsResponseUnmarshaller.Instance;

            return InvokeAsync<SwapEnvironmentCNAMEsRequest,SwapEnvironmentCNAMEsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  TerminateEnvironment

        internal TerminateEnvironmentResponse TerminateEnvironment(TerminateEnvironmentRequest request)
        {
            var marshaller = new TerminateEnvironmentRequestMarshaller();
            var unmarshaller = TerminateEnvironmentResponseUnmarshaller.Instance;

            return Invoke<TerminateEnvironmentRequest,TerminateEnvironmentResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the TerminateEnvironment operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the TerminateEnvironment operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<TerminateEnvironmentResponse> TerminateEnvironmentAsync(TerminateEnvironmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new TerminateEnvironmentRequestMarshaller();
            var unmarshaller = TerminateEnvironmentResponseUnmarshaller.Instance;

            return InvokeAsync<TerminateEnvironmentRequest,TerminateEnvironmentResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  UpdateApplication

        internal UpdateApplicationResponse UpdateApplication(UpdateApplicationRequest request)
        {
            var marshaller = new UpdateApplicationRequestMarshaller();
            var unmarshaller = UpdateApplicationResponseUnmarshaller.Instance;

            return Invoke<UpdateApplicationRequest,UpdateApplicationResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateApplication operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateApplication operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<UpdateApplicationResponse> UpdateApplicationAsync(UpdateApplicationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new UpdateApplicationRequestMarshaller();
            var unmarshaller = UpdateApplicationResponseUnmarshaller.Instance;

            return InvokeAsync<UpdateApplicationRequest,UpdateApplicationResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  UpdateApplicationVersion

        internal UpdateApplicationVersionResponse UpdateApplicationVersion(UpdateApplicationVersionRequest request)
        {
            var marshaller = new UpdateApplicationVersionRequestMarshaller();
            var unmarshaller = UpdateApplicationVersionResponseUnmarshaller.Instance;

            return Invoke<UpdateApplicationVersionRequest,UpdateApplicationVersionResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateApplicationVersion operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateApplicationVersion operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<UpdateApplicationVersionResponse> UpdateApplicationVersionAsync(UpdateApplicationVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new UpdateApplicationVersionRequestMarshaller();
            var unmarshaller = UpdateApplicationVersionResponseUnmarshaller.Instance;

            return InvokeAsync<UpdateApplicationVersionRequest,UpdateApplicationVersionResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  UpdateConfigurationTemplate

        internal UpdateConfigurationTemplateResponse UpdateConfigurationTemplate(UpdateConfigurationTemplateRequest request)
        {
            var marshaller = new UpdateConfigurationTemplateRequestMarshaller();
            var unmarshaller = UpdateConfigurationTemplateResponseUnmarshaller.Instance;

            return Invoke<UpdateConfigurationTemplateRequest,UpdateConfigurationTemplateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateConfigurationTemplate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateConfigurationTemplate operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<UpdateConfigurationTemplateResponse> UpdateConfigurationTemplateAsync(UpdateConfigurationTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new UpdateConfigurationTemplateRequestMarshaller();
            var unmarshaller = UpdateConfigurationTemplateResponseUnmarshaller.Instance;

            return InvokeAsync<UpdateConfigurationTemplateRequest,UpdateConfigurationTemplateResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  UpdateEnvironment

        internal UpdateEnvironmentResponse UpdateEnvironment(UpdateEnvironmentRequest request)
        {
            var marshaller = new UpdateEnvironmentRequestMarshaller();
            var unmarshaller = UpdateEnvironmentResponseUnmarshaller.Instance;

            return Invoke<UpdateEnvironmentRequest,UpdateEnvironmentResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateEnvironment operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateEnvironment operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<UpdateEnvironmentResponse> UpdateEnvironmentAsync(UpdateEnvironmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new UpdateEnvironmentRequestMarshaller();
            var unmarshaller = UpdateEnvironmentResponseUnmarshaller.Instance;

            return InvokeAsync<UpdateEnvironmentRequest,UpdateEnvironmentResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

        #region  ValidateConfigurationSettings

        internal ValidateConfigurationSettingsResponse ValidateConfigurationSettings(ValidateConfigurationSettingsRequest request)
        {
            var marshaller = new ValidateConfigurationSettingsRequestMarshaller();
            var unmarshaller = ValidateConfigurationSettingsResponseUnmarshaller.Instance;

            return Invoke<ValidateConfigurationSettingsRequest,ValidateConfigurationSettingsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ValidateConfigurationSettings operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ValidateConfigurationSettings operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<ValidateConfigurationSettingsResponse> ValidateConfigurationSettingsAsync(ValidateConfigurationSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ValidateConfigurationSettingsRequestMarshaller();
            var unmarshaller = ValidateConfigurationSettingsResponseUnmarshaller.Instance;

            return InvokeAsync<ValidateConfigurationSettingsRequest,ValidateConfigurationSettingsResponse>(request, marshaller,
                unmarshaller, cancellationToken);
        }

        #endregion

    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.auraframework.throwable.quickfix;

import org.auraframework.system.Location;

/**
 * Exception for client libraries
 */
public class ClientLibraryException extends QuickFixException {
    private static final long serialVersionUID = 288798091014190582L;

    public ClientLibraryException(String message, Location location) {
        super(message, location, (AuraQuickFix[]) null);
    }
}


text:
if [ `uname` == Darwin ] ; then
    extra_config_options="--disable-openmp
                          --enable-universal-binary
                          --without-python3
                          LDFLAGS=-Wl,-headerpad_max_install_names"
else ## linux
    extra_config_options="--with-python3 --with-python"

    ############################################################
    ## Vienna requires Python 2 and 3 at run time to generate Swig
    ## bindings for both. Since conda does not allow installation of both
    ## python versions in the same environment, we perform this
    ## workaround: install Python 2 in a different environment and set the
    ## path accordingly.
    ##

    ## install python 2.7 in separate environment
    conda create -y -n python2 'python<3'

    ## get path to python2 environment
    MY_PATH_BACKUP=${PATH}         # backup path
    source activate python2
    PYTHON2_ENV=${CONDA_PREFIX}
    source deactivate
    export PATH=${MY_PATH_BACKUP}  # restore path

    ## Vienna rna expects python-config executable as python2-config,
    ## unfortunately some python 2.7 conda packages do not install it.
    ## Workaround: set symbolic link
    if [ ! -e $PYTHON2_ENV/bin/python2-config ]; then
      ln -sf $PYTHON2_ENV/bin/python-config $PYTHON2_ENV/bin/python2-config
    fi

    ## Add python2 env to search path (don't use activate, since we want
    ## to stay in the build environment)
    export PATH=${PYTHON2_ENV}/bin:$PATH

    PY2LIB=-L${PYTHON2_ENV}/lib

    ##
    ############################################################

fi

## Configure and make
./configure --prefix=$PREFIX \
            --without-perl \
            --with-kinwalker \
            --disable-lto \
            --without-doc \
            ${extra_config_options} \
            LIBS=${PY2LIB} \
            &&\
make -j${CPU_COUNT}

## Install
make install


text:
'use strict';

const models = require('./index');

/**
 * Class representing a OperationResult.
 */
class OperationResult {
  /**
   * Create a OperationResult.
   * @member {string} [status] The status of the request. Possible values
   * include: 'Succeeded', 'Failed', 'canceled', 'Accepted', 'Creating',
   * 'Created', 'Updating', 'Updated', 'Deleting', 'Deleted', 'OK'
   * @member {object} [error]
   * @member {number} [error.code] The error code for an operation failure
   * @member {string} [error.message] The detailed arror message
   */
  constructor() {
  }

  /**
   * Defines the metadata of OperationResult
   *
   * @returns {object} metadata of OperationResult
   *
   */
  mapper() {
    return {
      required: false,
      serializedName: 'OperationResult',
      type: {
        name: 'Composite',
        className: 'OperationResult',
        modelProperties: {
          status: {
            required: false,
            serializedName: 'status',
            type: {
              name: 'String'
            }
          },
          error: {
            required: false,
            serializedName: 'error',
            type: {
              name: 'Composite',
              className: 'OperationResultError'
            }
          }
        }
      }
    };
  }
}

module.exports = OperationResult;


text:
Created by [Fahri Firdausillah](http://fahrifirdaus.web.id)

---

### List of Contents

- [What is stack?](#/1)
- [How Stack Works?](#/1)
- [Creating Stack Using Java](#/1)
- [Sample of Stack Manipulation](#/1)
- [Assignments](#/1)

---

### What is Stack?

- Stack is a data structure that forcing developer to use FILO as data flow
- FILO means the data inserted first can only be accessed last
- Different to regular array, stack can only access data in that particular order
- Stack is actually most usefull and important linear data structure

---

### How Stack Works?


text:
/**
 * ProductUnknownError.java
 *
 * This file was auto-generated from WSDL
 * by the Apache Axis2 version: 1.5.4  Built on : Dec 19, 2010 (08:18:42 CET)
 */

package es.upm.fi.sos.t3.shoppingcart;

public class ProductUnknownError extends java.lang.Exception{

    private es.upm.fi.sos.t3.shoppingcart.ErrorMessage faultMessage;

        public ProductUnknownError() {
            super("ProductUnknownError");
        }

        public ProductUnknownError(java.lang.String s) {
           super(s);
        }

        public ProductUnknownError(java.lang.String s, java.lang.Throwable ex) {
          super(s, ex);
        }

        public ProductUnknownError(java.lang.Throwable cause) {
            super(cause);
        }

    public void setFaultMessage(es.upm.fi.sos.t3.shoppingcart.ErrorMessage msg){
       faultMessage = msg;
    }

    public es.upm.fi.sos.t3.shoppingcart.ErrorMessage getFaultMessage(){
       return faultMessage;
    }
}


text:
module.exports = function clusterize () {
  var cluster = require('cluster')
    , config  = require('config');

  var isMaster = cluster.isMaster && config.app.clustered;

  if (isMaster && !isDevelopment) {
    var os = require('os');

    var cpus     = os.cpus().length
      , timeouts = []
      , timeout  = 2000;

    for (var i = 0; i < cpus; ++i) {
      cluster.fork();
    }

    cluster.on('fork', function onClusterFork (worker) {
      logger.debug('Forking worker #' + worker.id);
      timeouts[worker.id] = setTimeout(function workerTimeout () {
        logger.error('Worker taking too long to start');
      }, timeout);
    });

    cluster.on('listening', function onClusterListening (worker, address) {
      logger.info('Worker #' + worker.id + ' listening on port: ' + address.port);
      clearTimeout(timeouts[worker.id]);
    });

    cluster.on('online', function onClusterOnline (worker) {
      logger.debug('Worker # ' + worker.id + ' is online');
    });

    cluster.on('exit', function onClusterExit (worker, code, signal) {
      logger.error('Worker #' + worker.id + ' has exited with exitCode ' + worker.process.exitCode);
      clearTimeout(timeouts[worker.id]);

      if (worker.suicide !== true) {
        logger.warning('Worker #' + worker.id + ' did not commit suicide, restarting');
        cluster.fork();
      }
    });

    cluster.on('disconnect', function onClusterDisconnect (worker) {
      logger.warning('Worker #' + worker.id + ' has disconnected');
    });

    ['SIGINT', 'SIGTERM', 'SIGQUIT'].forEach(function forEachQuiSignal (signal) {
      process.on(signal, function onQuitSignals () {
        cluster.workers.forEach(function destroyWorker (worker) {
          worker.destroy();
        });
      });
    });
  } else {
    app.listen(config.app.port);
    logger.info('Listening on port: ' + config.app.port);
  }
};


text:
package buildcraft.api.blueprints;

import java.util.LinkedList;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;

/**
 * This class records a slot, either from a blueprint or from a block placed in the world.
 */

@Deprecated
public class BptSlotInfo {

	public int blockId = 0;
	public int meta = 0;
	public int x;
	public int y;
	public int z;

	/**
	 * This field contains requirements for a given block when stored in the blueprint. Modders can either rely on this list or compute their own int BptBlock.
	 */
	public LinkedList<ItemStack> storedRequirements = new LinkedList<ItemStack>();

	/**
	 * This tree contains additional data to be stored in the blueprint. By default, it will be initialized from BptBlock.initializeFromWorld with the standard
	 * readNBT function of the corresponding tile (if any) and will be loaded from BptBlock.buildBlock using the standard writeNBT function.
	 */
	public NBTTagCompound cpt = new NBTTagCompound();

	@Override
	public BptSlotInfo clone() {
		BptSlotInfo obj = new BptSlotInfo();

		obj.x = x;
		obj.y = y;
		obj.z = z;
		obj.blockId = blockId;
		obj.meta = meta;
		obj.cpt = (NBTTagCompound) cpt.copy();

		return obj;
	}

}


text:
using System;
using System.Text;

public abstract class Provider : Worker
{
    private string id;
    private double energyOutput;

    protected Provider(string id, double energyOutput) : base(id)
    {
        this.Id = id;
        this.EnergyOutput = energyOutput;
    }

    public double EnergyOutput
    {
        get { return this.energyOutput; }
        protected set
        {
            if (value < 0 || value >= 10000)
            {
                throw new ArgumentException($"Provider is not registered, because of it's EnergyOutput");
            }

            this.energyOutput = value;
        }
    }

    protected string Id
    {
        get { return id; }
        set { id = value; }
    }

    public override string ToString()
    {
        var sb = new StringBuilder();

        var type = this.GetType().Name;
        var index = type.IndexOf("Provider");
        type = type.Remove(index);

        sb.AppendLine($"{type} Provider - {this.Id}");
        sb.AppendLine($"Energy Output: {this.EnergyOutput}");

        return sb.ToString().Trim();
    }
}


text:
<!DOCTYPE html>

      <meta http-equiv="content-type" content="text/html; charset=UTF-8">
      <link rel="stylesheet" type="text/css" href="../css/layout.css" media="all">
      <link rel="stylesheet" type="text/css" href="http://fonts.googleapis.com/css?family=Noto+Sans">

      <title>Thegither PyBake 2013 Job Board (DEMO)</title>

PyBake 2013 Job Board (DEMO)

                  test@example.com

CSS layout and design

Edit this post

The PyBake Planning Committee provides this job board as a service to the sponsors and attendees of the PyBake 2013 Decamp.

─Please do not post to this board if you are not a sponsor or attendee of PyBake 2013.

─If you are a sponsor, please do not post a job unless you are hiring for it now.

─If you are an attendee, please do not post unless you are available immediately.

Please do not abuse this board.  If the adminstrators believe you are abusing it, they will remove your post.

                        Posted on: 2013-10-09 20:43:25.548069

                        We're Hiring: CSS layout and design

Medium Artis is looking for a graphic designer who has at least 4 years experience with CSS and HTML.

We're a small studio in Edina with some important clients.  Creativity is appreciated here.  If you can show us a portfolio of your work, that would significantly help us evaluate whether you're a fit.

Some experience with HTML5 is a plus.

Come visit us at our booth on the mezzanine level during lunch and between sessions.  We'd love to chat.

Responses

I am a skilled graphics designer who can satisfy your clients.  I earned a BA in Graphic Arts from the Minneapolis College of Art and Design, and have seven years experience working with Photoshop, Blender, CSS, and HTML5. —
                           a@example.com

A' thegither they will sup!


text:
@class BTPaymentMethodNonce;
@protocol BTAppSwitchDelegate;
@protocol BTViewControllerPresentingDelegate;

NS_ASSUME_NONNULL_BEGIN

/// The primary UIViewController for Drop-In. BTDropInController will manage the other UIViewControllers and return a BTDropInResult.
@interface BTDropInController : UIViewController <UIToolbarDelegate, UIViewControllerTransitioningDelegate>

typedef void (^BTDropInControllerHandler)(BTDropInController * _Nonnull controller, BTDropInResult * _Nullable result, NSError * _Nullable error);

/// Initialize a new Drop-in view controller.
///
/// @param authorization A Braintree tokenization key, or a client token generated by your server.
/// Passing an invalid value may return `nil`.
/// @param handler A callback block that is invoked when tokenization has succeeded or failed.
///
/// @return A Drop-in controller that is ready to be presented, or `nil` if `authorization` is invalid.
- (nullable instancetype)initWithAuthorization:(NSString *)authorization
                                       request:(BTDropInRequest *)request
                                       handler:(nullable BTDropInControllerHandler)handler;

/// The API client used for communication with Braintree servers.
@property (nonatomic, strong, readonly) BTAPIClient *apiClient;

/// The BTDropInRequest used to customize Drop-in
@property (nonatomic, strong, readonly) BTDropInRequest *dropInRequest;

/// Show the BTCardFormViewController
///
/// @param sender The sender requesting the view be changed.
- (void)showCardForm:(id)sender;

@end

@protocol BTDropInControllerDelegate <NSObject>

- (void)reloadDropInData;

@end

NS_ASSUME_NONNULL_END


text:
Run and serve your web apps in .test domains on your develop machine.

![a](https://user-images.githubusercontent.com/1559832/27260786-ccb150de-5488-11e7-9cb5-44b98d5fdad2.gif)

This project is inspired by:

* [37 Signals' Pow](http://pow.cx/) (Rack, OS X only)
* [typicode/hotel](https://github.com/typicode/hotel)

Comparing to hotel, this project comes with a few extra features:

* Full-fledged / operable terminal (powered by battle-hardened [node-pty](https://github.com/Tyriar/node-pty) and [xterm.js](https://github.com/sourcelair/xterm.js/))
* Also shipped as an Electron / GUI app (available on Linux / OS X / Windows)
* Robust state control (easily and reliably restarting app when needed)
* Proxy all network request (so you don't have to setup proxy auto-config, just use the single proxy, makes it easy for cross-projects API invocation)
* Self-signed SSL connection (with correct SAN so it produces a 'greenlock' after marking CA trusted manually)
* Set a timeout option so application will be automatically shutdown

## Install

If you prefer launching and keeping it by CLI, then

```
npm install localhostd -g
localhostd server
```

... or if you prefer launching it as a GUI staying as a tray icon, [download the latest release](https://github.com/layerssss/localhostd/releases).

## Usage

Configure your brower to use `http://localhost:2999` as HTTP/HTTPS proxy. Then add your apps in http://localhostd.test/ (or in GUI), specifying the directory and the command to run your application.

Make sure they listen to the HTTP port number specified in the `PORT` enviroment variable. Here are some examples commands:

* `ember server`
* `jekyll server`
* `rails server --port $PORT --bind 127.0.0.1` `--bind 127.0.0.1` is for OSX otherwise rails will be using a special localhost socket which is not accessible by Node.js API
* `python -m SimpleHTTPServer $PORT`
* `php -S 127.0.0.1:$PORT`

Then click the 🌎 button in the app details to go to its `.test` domain. `localhostd` will launch your app for you.

## Self-signed SSL

`localhostd` generates a self-signed CA key-pair and stores it with other data at `~/.localhostd.json`. Then it signs SSL certificate for each `.test` domain when requested. So SSL works out of box, just by going to `https://my-app.test/`. But if want to see a 'greenlock', i.e. to make your browser trust `localhostd`, you need to mark your self-signed CA as trusted in browser or OS.

## License

[MIT - Michael Yin](LICENSE)


text:
package io.github.benas.randombeans;

import io.github.benas.randombeans.annotation.Priority;
import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

public class PriorityComparatorTest {

    private PriorityComparator priorityComparator;

    private Foo foo;

    private Bar bar;

    @Before
    public void setUp() {
        priorityComparator = new PriorityComparator();
        foo = new Foo();
        bar = new Bar();
    }

    @Test
    public void testCompare() {
        assertThat(priorityComparator.compare(foo, bar)).isGreaterThan(0);

        List<Object> objects = Arrays.asList(foo,bar);
        Collections.sort(objects, priorityComparator);
        // objects must be sorted in decreasing priority order: 2 > 1
        assertThat(objects).containsExactly(bar, foo);
    }

    @Priority(1)
    private class Foo {

    }

    @Priority(2)
    private class Bar {

    }
}


text:
// Copyright 2020 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.

#ifndef COMPONENTS_PERFORMANCE_MANAGER_SERVICE_WORKER_CONTEXT_ADAPTER_H_
#define COMPONENTS_PERFORMANCE_MANAGER_SERVICE_WORKER_CONTEXT_ADAPTER_H_

#include <memory>
#include <string>

#include "base/check_op.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/observer_list.h"
#include "base/scoped_observation.h"
#include "content/public/browser/service_worker_context.h"
#include "content/public/browser/service_worker_context_observer.h"

namespace blink {
class StorageKey;
}  // namespace blink

namespace performance_manager {

// This class adapts an existing ServiceWorkerContext to ensure that the
// OnVersionStoppedRunning() notifications are sent as soon as the render
// process of a running service worker exits.
//
// It implements ServiceWorkerContext so it can be used interchangeably where a
// ServiceWorkerContext* is needed, and it also observes the underlying context
// so that it can receive the original notifications and control when they are
// sent to the observers.
//
// Lives on the UI thread. Must outlive |underlying_context|.
//
// Note: This is a temporary class that can be removed when the representation
//       of a worker in the content/ layer (ServiceWorkerVersion) is moved to
//       the UI thread. At that point, it'll be able to observe its associated
//       RenderProcessHost itself. See https://crbug.com/824858.
class ServiceWorkerContextAdapter
    : public content::ServiceWorkerContext,
      public content::ServiceWorkerContextObserver {
 public:
  explicit ServiceWorkerContextAdapter(
      content::ServiceWorkerContext* underlying_context);
  ~ServiceWorkerContextAdapter() override;

  // content::ServiceWorkerContext:
  // Note that this is a minimal implementation for the use case of the
  // PerformanceManager. Only AddObserver/RemoveObserver are implemented.
  void AddObserver(content::ServiceWorkerContextObserver* observer) override;
  void RemoveObserver(content::ServiceWorkerContextObserver* observer) override;
  void RegisterServiceWorker(
      const GURL& script_url,
      const blink::StorageKey& key,
      const blink::mojom::ServiceWorkerRegistrationOptions& options,
      StatusCodeCallback callback) override;
  void UnregisterServiceWorker(const GURL& scope,
                               const blink::StorageKey& key,
                               ResultCallback callback) override;
  content::ServiceWorkerExternalRequestResult StartingExternalRequest(
      int64_t service_worker_version_id,
      content::ServiceWorkerExternalRequestTimeoutType timeout_type,
      const std::string& request_uuid) override;
  content::ServiceWorkerExternalRequestResult FinishedExternalRequest(
      int64_t service_worker_version_id,
      const std::string& request_uuid) override;
  size_t CountExternalRequestsForTest(const blink::StorageKey& key) override;
  bool ExecuteScriptForTest(
      const std::string& script,
      int64_t service_worker_version_id,
      content::ServiceWorkerScriptExecutionCallback callback) override;
  bool MaybeHasRegistrationForStorageKey(const blink::StorageKey& key) override;
  void GetAllOriginsInfo(GetUsageInfoCallback callback) override;
  void DeleteForStorageKey(const blink::StorageKey& key,
                           ResultCallback callback) override;
  void CheckHasServiceWorker(const GURL& url,
                             const blink::StorageKey& key,
                             CheckHasServiceWorkerCallback callback) override;
  void CheckOfflineCapability(const GURL& url,
                              const blink::StorageKey& key,
                              CheckOfflineCapabilityCallback callback) override;
  void ClearAllServiceWorkersForTest(base::OnceClosure callback) override;
  void StartWorkerForScope(const GURL& scope,
                           const blink::StorageKey& key,
                           StartWorkerCallback info_callback,
                           StatusCodeCallback failure_callback) override;
  void StartServiceWorkerAndDispatchMessage(
      const GURL& scope,
      const blink::StorageKey& key,
      blink::TransferableMessage message,
      ResultCallback result_callback) override;
  void StartServiceWorkerForNavigationHint(
      const GURL& document_url,
      const blink::StorageKey& key,
      StartServiceWorkerForNavigationHintCallback callback) override;
  void StopAllServiceWorkersForStorageKey(
      const blink::StorageKey& key) override;
  void StopAllServiceWorkers(base::OnceClosure callback) override;
  const base::flat_map<int64_t /* version_id */,
                       content::ServiceWorkerRunningInfo>&
  GetRunningServiceWorkerInfos() override;

  // content::ServiceWorkerContextObserver:
  void OnRegistrationCompleted(const GURL& scope) override;
  void OnRegistrationStored(int64_t registration_id,
                            const GURL& scope) override;
  void OnVersionActivated(int64_t version_id, const GURL& scope) override;
  void OnVersionRedundant(int64_t version_id, const GURL& scope) override;
  void OnVersionStartedRunning(
      int64_t version_id,
      const content::ServiceWorkerRunningInfo& running_info) override;
  void OnVersionStoppedRunning(int64_t version_id) override;
  void OnControlleeAdded(
      int64_t version_id,
      const std::string& client_uuid,
      const content::ServiceWorkerClientInfo& client_info) override;
  void OnControlleeRemoved(int64_t version_id,
                           const std::string& client_uuid) override;
  void OnNoControllees(int64_t version_id, const GURL& scope) override;
  void OnControlleeNavigationCommitted(
      int64_t version_id,
      const std::string& uuid,
      content::GlobalRenderFrameHostId render_frame_host_id) override;
  void OnReportConsoleMessage(int64_t version_id,
                              const GURL& scope,
                              const content::ConsoleMessage& message) override;
  void OnDestruct(ServiceWorkerContext* context) override;

 private:
  class RunningServiceWorker;

  // Invoked by a RunningServiceWorker when it observes that the render process
  // has exited.
  void OnRenderProcessExited(int64_t version_id);

  // Adds a registration to |worker_process_host| that will result in
  // |OnRenderProcessExited| with |version_id| when it exits.
  void AddRunningServiceWorker(int64_t version_id,
                               content::RenderProcessHost* worker_process_host);

  // Removes a registration made by |AddRunningServiceWorker| if one exists,
  // returns true if a registration existed, false otherwise.
  bool MaybeRemoveRunningServiceWorker(int64_t version_id);

  base::ScopedObservation<content::ServiceWorkerContext,
                          content::ServiceWorkerContextObserver>
      scoped_underlying_context_observation_{this};

  base::ObserverList<content::ServiceWorkerContextObserver, true, false>::
      Unchecked observer_list_;

  // For each running service worker, tracks when their render process exits.
  base::flat_map<int64_t /*version_id*/, std::unique_ptr<RunningServiceWorker>>
      running_service_workers_;

  // Tracks the OnControlleeAdded and OnControlleeRemoved notification for each
  // service worker, with the goal of cleaning up duplicate notifications for
  // observers of this class.
  // TODO(1015692): Fix the underlying code in content/browser/service_worker so
  //                that duplicate notifications are no longer sent.
  base::flat_map<int64_t /*version_id*/,
                 base::flat_set<std::string /*client_uuid*/>>
      service_worker_clients_;

#if DCHECK_IS_ON()
  // Keeps track of service worker whose render process exited early.
  base::flat_set<int64_t> stopped_service_workers_;
#endif  // DCHECK_IS_ON()
};

}  // namespace performance_manager

#endif  // COMPONENTS_PERFORMANCE_MANAGER_SERVICE_WORKER_CONTEXT_ADAPTER_H_


text:
```
      _________________
     /  ______        /
    /  / ____/__     / ____________  ______ ___
   /  / /_  / _ \   / / ___/ ___/ / / / __ `__ \
  /  / __/ /  __/  / / /  / /  / /_/ / / / / / /
 /  /_/    \___/  / /_/  /_/   \__,_/_/ /_/ /_/
/________________/
```

# TL;DR

Ferrum is a framework for ruby Iron worker tasks. Use it to gather metrics about your task.

# Getting Started

1. Worker file http://dev.iron.io/worker/reference/dotworker/
2. Create a runner
  Here's a basic runner...

    ```
    require 'fe'

    Fe.configure do
    end

    Fe.run do |params|
    end
    ```

  Use the `Fe.configure` block to setup your worker, and the `Fe.run` block for execution.

## Code
Each task has a code bundle, a worker file, and a runner.

## Manage - Orbital
Watches the execution of code. Use it to handle task configuration and gathering information about code execution. Some example uses include...
- Logging
- Configuration
- Metrics
- Error reporting

## Metrics - Valence
An optional component that provides a uniform API for events and metrics. Valence is responsible for communicating to adapters.

## Adapters
Distribute information to external services. This could be logging, exception reporting, metrics, etc.

### Standard Output (todo)
Log to STDOUT

### File
Log to file (todo)

### Datadog
Search and correlate metrics and events

### Statsd (todo)
Simple daemon for easy stats aggregation

### Papertrail (todo)
Hosted log management for servers, apps, and cloud services.

### Exceptional & Airbrake (todo)
Collects errors generated by other applications, and aggregates the results for review.

### NewRelic (todo)
New Relic is the all-in-one web application performance tool that lets you see performance from the end user experience, through servers, and down to the line of application code.


text:
<?php

/**
 * The FtpException class.
 * Exception thrown if an error on runtime of the FTP client occurs.
 * @inheritDoc
 * @author Nicolas Tallefourtane <dev@nicolab.net>
 */
class AddOnInstaller_FtpClient_FtpException extends XenForo_Exception
{
}


text:
(function () {

  // create
  angular
    .module('<%= projectInternalName %>', [])
    .controller('HomeController', [HomeController])
    .config(['$logProvider', function ($logProvider) {
      // set debug logging to on
      if ($logProvider.debugEnabled) {
        $logProvider.debugEnabled(true);
      }
    }]);

  /**
   * Home Controller
   */
  function HomeController() {
    this.title = 'Home';
    console.log(`${this.title} is ready!`);

    this.run = async () => {
      <% if (host === 'Outlook') { %>
      <%# Outlook doesn't expose Outlook.run(), so don't put that in %>
      /**
       * Insert your <%= host %> code here
       */
      <% } else { %>
      await <%= host %>.run(async (context) => {
        /**
         * Insert your <%= host %> code here
         */
        await context.sync();
      });
      <% } %>
    }
  }

  // when Office has initalized, manually bootstrap the app
  Office.initialize = function () {
    angular.bootstrap(document.body, ['<%= projectInternalName %>']);
  };

})();


text:
import React from "react";
import { BooleanMCUInputGroup } from "./boolean_mcu_input_group";
import { ToolTips, DeviceSetting, Content } from "../../constants";
import { LimitSwitchesProps } from "./interfaces";
import { Header } from "./header";
import { Collapse } from "@blueprintjs/core";
import { Highlight } from "../maybe_highlight";
import { SpacePanelHeader } from "./space_panel_header";
import { settingRequiredLabel } from "./encoders_or_stall_detection";
import { t } from "../../i18next_wrapper";
import { getDefaultFwConfigValue } from "./default_values";
import { McuParamName } from "farmbot";
import { some } from "lodash";

export function LimitSwitches(props: LimitSwitchesProps) {

  const { limit_switches } = props.controlPanelState;
  const { dispatch, sourceFwConfig, arduinoBusy, firmwareHardware } = props;

  const commonProps = {
    dispatch,
    sourceFwConfig,
    disabled: arduinoBusy,
    firmwareHardware,
  };

  const anyModified = some([
    "movement_enable_endpoints_x",
    "movement_enable_endpoints_y",
    "movement_enable_endpoints_z",
  ].map((key: McuParamName) =>
    getDefaultFwConfigValue(props.firmwareHardware)(key)
    != props.sourceFwConfig(key).value));

  return <Highlight className={"section advanced"}
    settingName={DeviceSetting.limitSwitchSettings}
    hidden={!(props.showAdvanced || anyModified)}>

    <Collapse isOpen={!!limit_switches}>
      <Highlight settingName={DeviceSetting.limitSwitchesWarning}>

{t(Content.LIMIT_SWITCH_WARNING)}

      </Highlight>
      <SpacePanelHeader />
      <BooleanMCUInputGroup {...commonProps}
        label={DeviceSetting.enableLimitSwitches}
        tooltip={ToolTips.ENABLE_LIMIT_SWITCHES}
        x={"movement_enable_endpoints_x"}
        y={"movement_enable_endpoints_y"}
        z={"movement_enable_endpoints_z"} />
      <BooleanMCUInputGroup {...commonProps}
        label={DeviceSetting.swapLimitSwitches}
        tooltip={ToolTips.SWAP_LIMIT_SWITCHES}
        x={"movement_invert_endpoints_x"}
        y={"movement_invert_endpoints_y"}
        z={"movement_invert_endpoints_z"}
        grayscale={{
          x: !sourceFwConfig("movement_enable_endpoints_x").value,
          y: !sourceFwConfig("movement_enable_endpoints_y").value,
          z: !sourceFwConfig("movement_enable_endpoints_z").value
        }}
        disabledBy={settingRequiredLabel([DeviceSetting.enableLimitSwitches])} />
      <BooleanMCUInputGroup {...commonProps}
        label={DeviceSetting.invertLimitSwitches}
        tooltip={ToolTips.INVERT_LIMIT_SWITCHES}
        x={"movement_invert_2_endpoints_x"}
        y={"movement_invert_2_endpoints_y"}
        z={"movement_invert_2_endpoints_z"}
        grayscale={{
          x: !sourceFwConfig("movement_enable_endpoints_x").value,
          y: !sourceFwConfig("movement_enable_endpoints_y").value,
          z: !sourceFwConfig("movement_enable_endpoints_z").value
        }}
        disabledBy={settingRequiredLabel([DeviceSetting.enableLimitSwitches])} />
    </Collapse>
  </Highlight>;
}


text:
<tool id="bamtools_split_tag" name="Split BAM by Tag" version="@VERSION@">
    <description>into dataset list collection</description>
    <macros>
          <import>macros.xml</import>
    </macros>
    <expand macro="requirements" />
    <command>
        <![CDATA[
            #import re
            #set $name = 'split_bam' + $re.sub('\W','_',$re.sub('\.bam$','',$input_bam.name))
            ln -s '${input_bam}' 'localbam.bam' &&
            ln -s '${input_bam.metadata.bam_index}' 'localbam.bam.bai' &&
            bamtools split -tag $tag_name
            -in 'localbam.bam'
            -stub '$name'
        ]]>
    </command>
    <inputs>
        <param name="input_bam" type="data" format="bam" label="BAM dataset to split by tag value"/>
        <param name="tag_name" type="text" value="NM" label="Enter tag name here" help="For example, to split on NM tag enter "NM""/>
    </inputs>
    <outputs>
        <collection name="output_bams" type="list" label="${input_bam.name} Split List">
            <discover_datasets pattern="split_bam(?P<designation>.+)\.bam" ext="bam" visible="false"/>
        </collection>
    </outputs>
    <tests>
        <test>
            <param name="input_bam" ftype="bam" value="bamtools-input-tags.bam"/>
            <param name="tag_name" value="XG"/>
            <output_collection name="output_bams"  type="list">
                <element name="bamtools_input_tags.TAG_XG_V"  file="bamtools_input_tags.TAG_XG_V.bam" compare="sim_size" delta="500" />
            </output_collection>
        </test>

    </tests>
    <help>
**What is does**

BAMTools split is a utility for splitting BAM files. It is based on BAMtools suite of tools by Derek Barnett (https://github.com/pezmaster31/bamtools).

-----

.. class:: warningmark

**DANGER: Multiple Outputs**

As described below, splitting a BAM dataset(s) on tag value can produce very large numbers of outputs. Read below and know what you are doing.

-----

**How it works**

Split alignments by tag name into a dataset list collection.

This can generate a huge number of output datasets depending on the number of distinct values of the TAG.

-----

.. class:: infomark

**More information**

Additional information about BAMtools can be found at https://github.com/pezmaster31/bamtools/wiki

    </help>
    <citations>
        <citation type="doi">10.1093/bioinformatics/btr174</citation>
    </citations>
</tool>