text:
/*
 * Do not modify this file. This file is generated from the cloudformation-2010-05-15.normal.json service model.
 */

using System;
using System.Collections.Generic;

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

namespace Amazon.CloudFormation
{
    ///
    /// Implementation for accessing CloudFormation
    ///
    /// AWS CloudFormation
    /// <para>
    /// AWS CloudFormation enables you to create and manage AWS infrastructure deployments
    /// predictably and repeatedly. AWS CloudFormation helps you leverage AWS products such
    /// as Amazon EC2, EBS, Amazon SNS, ELB, and Auto Scaling to build highly-reliable, highly
    /// scalable, cost effective applications without worrying about creating and configuring
    /// the underlying AWS infrastructure.
    /// </para>
    ///
    /// <para>
    /// With AWS CloudFormation, you declare all of your resources and dependencies in a template
    /// file. The template defines a collection of resources as a single unit called a stack.
    /// AWS CloudFormation creates and deletes all member resources of the stack together
    /// and manages all dependencies between the resources for you.
    /// </para>
    ///
    /// <para>
    /// For more information about this product, go to the CloudFormation
    /// Product Page.
    /// </para>
    ///
    /// <para>
    /// Amazon CloudFormation makes use of other AWS products. If you need additional technical
    /// information about a specific AWS product, you can find the product's technical documentation
    /// at http://aws.amazon.com/documentation/.
    /// </para>
    ///
    public partial class AmazonCloudFormationClient : AmazonServiceClient, IAmazonCloudFormation
    {
        #region Constructors

        ///
        /// Constructs AmazonCloudFormationClient with the credentials loaded from the application's
        /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
        ///
        /// Example App.config with credentials set.
        ///
        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///
        ///
        ///
        public AmazonCloudFormationClient()
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonCloudFormationConfig()) { }

        ///
        /// Constructs AmazonCloudFormationClient with the credentials loaded from the application's
        /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
        ///
        /// Example App.config with credentials set.
        ///
        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///
        ///
        ///
        /// <param name="region">The region to connect.</param>
        public AmazonCloudFormationClient(RegionEndpoint region)
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonCloudFormationConfig{RegionEndpoint = region}) { }

        ///
        /// Constructs AmazonCloudFormationClient with the credentials loaded from the application's
        /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
        ///
        /// Example App.config with credentials set.
        ///
        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///
        ///
        ///
        /// <param name="config">The AmazonCloudFormationClient Configuration Object</param>
        public AmazonCloudFormationClient(AmazonCloudFormationConfig config)
            : base(FallbackCredentialsFactory.GetCredentials(), config) { }

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

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

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

        ///
        /// Constructs AmazonCloudFormationClient 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 AmazonCloudFormationClient(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonCloudFormationConfig())
        {
        }

        ///
        /// Constructs AmazonCloudFormationClient 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 AmazonCloudFormationClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonCloudFormationConfig() {RegionEndpoint=region})
        {
        }

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

        ///
        /// Constructs AmazonCloudFormationClient 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 AmazonCloudFormationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonCloudFormationConfig())
        {
        }

        ///
        /// Constructs AmazonCloudFormationClient 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 AmazonCloudFormationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonCloudFormationConfig{RegionEndpoint = region})
        {
        }

        ///
        /// Constructs AmazonCloudFormationClient with AWS Access Key ID, AWS Secret Key and an
        /// AmazonCloudFormationClient 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 AmazonCloudFormationClient Configuration Object</param>
        public AmazonCloudFormationClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonCloudFormationConfig clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
        {
        }

        #endregion

        #region Overrides

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

        ///
        /// Customize the pipeline
        ///
        /// <param name="pipeline"></param>
        protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
        {
            pipeline.AddHandlerAfter<Amazon.Runtime.Internal.Marshaller>(new Amazon.CloudFormation.Internal.ProcessRequestHandler());
        }

        #endregion

        #region Dispose

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

        #endregion

        #region  CancelUpdateStack

        ///
        /// Cancels an update on the specified stack. If the call completes successfully, the
        /// stack will roll back the update and revert to the previous stack configuration.
        ///
        ///  <note>Only stacks that are in the UPDATE_IN_PROGRESS state can be canceled.</note>
        ///
        /// <param name="request">Container for the necessary parameters to execute the CancelUpdateStack service method.</param>
        ///
        /// <returns>The response from the CancelUpdateStack service method, as returned by CloudFormation.</returns>
        public CancelUpdateStackResponse CancelUpdateStack(CancelUpdateStackRequest request)
        {
            var marshaller = new CancelUpdateStackRequestMarshaller();
            var unmarshaller = CancelUpdateStackResponseUnmarshaller.Instance;

            return Invoke<CancelUpdateStackRequest,CancelUpdateStackResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CancelUpdateStack operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CancelUpdateStack operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelUpdateStack
        ///         operation.</returns>
        public IAsyncResult BeginCancelUpdateStack(CancelUpdateStackRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new CancelUpdateStackRequestMarshaller();
            var unmarshaller = CancelUpdateStackResponseUnmarshaller.Instance;

            return BeginInvoke<CancelUpdateStackRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  CancelUpdateStack operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelUpdateStack.</param>
        ///
        /// <returns>Returns a  CancelUpdateStackResult from CloudFormation.</returns>
        public  CancelUpdateStackResponse EndCancelUpdateStack(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelUpdateStackResponse>(asyncResult);
        }

        #endregion

        #region  CreateStack

        ///
        /// Creates a stack as specified in the template. After the call completes successfully,
        /// the stack creation starts. You can check the status of the stack via the DescribeStacks
        /// API.
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateStack service method.</param>
        ///
        /// <returns>The response from the CreateStack service method, as returned by CloudFormation.</returns>
        /// <exception cref="Amazon.CloudFormation.Model.AlreadyExistsException">
        /// Resource with the name requested already exists.
        /// </exception>
        /// <exception cref="Amazon.CloudFormation.Model.InsufficientCapabilitiesException">
        /// The template contains resources with capabilities that were not specified in the Capabilities
        /// parameter.
        /// </exception>
        /// <exception cref="Amazon.CloudFormation.Model.LimitExceededException">
        /// Quota for the resource has already been reached.
        /// </exception>
        public CreateStackResponse CreateStack(CreateStackRequest request)
        {
            var marshaller = new CreateStackRequestMarshaller();
            var unmarshaller = CreateStackResponseUnmarshaller.Instance;

            return Invoke<CreateStackRequest,CreateStackResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the CreateStack operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the CreateStack operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateStack
        ///         operation.</returns>
        public IAsyncResult BeginCreateStack(CreateStackRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new CreateStackRequestMarshaller();
            var unmarshaller = CreateStackResponseUnmarshaller.Instance;

            return BeginInvoke<CreateStackRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  CreateStack operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateStack.</param>
        ///
        /// <returns>Returns a  CreateStackResult from CloudFormation.</returns>
        public  CreateStackResponse EndCreateStack(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateStackResponse>(asyncResult);
        }

        #endregion

        #region  DeleteStack

        ///
        /// Deletes a specified stack. Once the call completes successfully, stack deletion starts.
        /// Deleted stacks do not show up in the DescribeStacks API if the deletion has
        /// been completed successfully.
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteStack service method.</param>
        ///
        /// <returns>The response from the DeleteStack service method, as returned by CloudFormation.</returns>
        public DeleteStackResponse DeleteStack(DeleteStackRequest request)
        {
            var marshaller = new DeleteStackRequestMarshaller();
            var unmarshaller = DeleteStackResponseUnmarshaller.Instance;

            return Invoke<DeleteStackRequest,DeleteStackResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DeleteStack operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteStack operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteStack
        ///         operation.</returns>
        public IAsyncResult BeginDeleteStack(DeleteStackRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DeleteStackRequestMarshaller();
            var unmarshaller = DeleteStackResponseUnmarshaller.Instance;

            return BeginInvoke<DeleteStackRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  DeleteStack operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteStack.</param>
        ///
        /// <returns>Returns a  DeleteStackResult from CloudFormation.</returns>
        public  DeleteStackResponse EndDeleteStack(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteStackResponse>(asyncResult);
        }

        #endregion

        #region  DescribeStackEvents

        ///
        /// Returns all stack related events for a specified stack. For more information about
        /// a stack's event history, go to Stacks
        /// in the AWS CloudFormation User Guide.
        ///
        ///  <note>You can list events for stacks that have failed to create or have been deleted
        /// by specifying the unique stack identifier (stack ID).</note>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackEvents service method.</param>
        ///
        /// <returns>The response from the DescribeStackEvents service method, as returned by CloudFormation.</returns>
        public DescribeStackEventsResponse DescribeStackEvents(DescribeStackEventsRequest request)
        {
            var marshaller = new DescribeStackEventsRequestMarshaller();
            var unmarshaller = DescribeStackEventsResponseUnmarshaller.Instance;

            return Invoke<DescribeStackEventsRequest,DescribeStackEventsResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeStackEvents operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackEvents operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStackEvents
        ///         operation.</returns>
        public IAsyncResult BeginDescribeStackEvents(DescribeStackEventsRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeStackEventsRequestMarshaller();
            var unmarshaller = DescribeStackEventsResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeStackEventsRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  DescribeStackEvents operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStackEvents.</param>
        ///
        /// <returns>Returns a  DescribeStackEventsResult from CloudFormation.</returns>
        public  DescribeStackEventsResponse EndDescribeStackEvents(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStackEventsResponse>(asyncResult);
        }

        #endregion

        #region  DescribeStackResource

        ///
        /// Returns a description of the specified resource in the specified stack.
        ///
        ///
        /// <para>
        /// For deleted stacks, DescribeStackResource returns resource information for up to 90
        /// days after the stack has been deleted.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackResource service method.</param>
        ///
        /// <returns>The response from the DescribeStackResource service method, as returned by CloudFormation.</returns>
        public DescribeStackResourceResponse DescribeStackResource(DescribeStackResourceRequest request)
        {
            var marshaller = new DescribeStackResourceRequestMarshaller();
            var unmarshaller = DescribeStackResourceResponseUnmarshaller.Instance;

            return Invoke<DescribeStackResourceRequest,DescribeStackResourceResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeStackResource operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackResource operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStackResource
        ///         operation.</returns>
        public IAsyncResult BeginDescribeStackResource(DescribeStackResourceRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeStackResourceRequestMarshaller();
            var unmarshaller = DescribeStackResourceResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeStackResourceRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  DescribeStackResource operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStackResource.</param>
        ///
        /// <returns>Returns a  DescribeStackResourceResult from CloudFormation.</returns>
        public  DescribeStackResourceResponse EndDescribeStackResource(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStackResourceResponse>(asyncResult);
        }

        #endregion

        #region  DescribeStackResources

        ///
        /// Returns AWS resource descriptions for running and deleted stacks. If StackName
        /// is specified, all the associated resources that are part of the stack are returned.
        /// If PhysicalResourceId is specified, the associated resources of the stack
        /// that the resource belongs to are returned.
        ///
        ///  <note>Only the first 100 resources will be returned. If your stack has more resources
        /// than this, you should use ListStackResources instead.</note>
        /// <para>
        /// For deleted stacks, DescribeStackResources returns resource information
        /// for up to 90 days after the stack has been deleted.
        /// </para>
        ///
        /// <para>
        /// You must specify either StackName or PhysicalResourceId,
        /// but not both. In addition, you can specify LogicalResourceId to filter
        /// the returned result. For more information about resources, the LogicalResourceId
        /// and PhysicalResourceId, go to the AWS
        /// CloudFormation User Guide.
        /// </para>
        ///  <note>A ValidationError is returned if you specify both StackName
        /// and PhysicalResourceId in the same request.</note>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackResources service method.</param>
        ///
        /// <returns>The response from the DescribeStackResources service method, as returned by CloudFormation.</returns>
        public DescribeStackResourcesResponse DescribeStackResources(DescribeStackResourcesRequest request)
        {
            var marshaller = new DescribeStackResourcesRequestMarshaller();
            var unmarshaller = DescribeStackResourcesResponseUnmarshaller.Instance;

            return Invoke<DescribeStackResourcesRequest,DescribeStackResourcesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeStackResources operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStackResources operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStackResources
        ///         operation.</returns>
        public IAsyncResult BeginDescribeStackResources(DescribeStackResourcesRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeStackResourcesRequestMarshaller();
            var unmarshaller = DescribeStackResourcesResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeStackResourcesRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  DescribeStackResources operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStackResources.</param>
        ///
        /// <returns>Returns a  DescribeStackResourcesResult from CloudFormation.</returns>
        public  DescribeStackResourcesResponse EndDescribeStackResources(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStackResourcesResponse>(asyncResult);
        }

        #endregion

        #region  DescribeStacks

        ///
        /// Returns the description for the specified stack; if no stack name was specified, then
        /// it returns the description for all the stacks created.
        ///
        ///
        /// <returns>The response from the DescribeStacks service method, as returned by CloudFormation.</returns>
        public DescribeStacksResponse DescribeStacks()
        {
            return DescribeStacks(new DescribeStacksRequest());
        }

        ///
        /// Returns the description for the specified stack; if no stack name was specified, then
        /// it returns the description for all the stacks created.
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStacks service method.</param>
        ///
        /// <returns>The response from the DescribeStacks service method, as returned by CloudFormation.</returns>
        public DescribeStacksResponse DescribeStacks(DescribeStacksRequest request)
        {
            var marshaller = new DescribeStacksRequestMarshaller();
            var unmarshaller = DescribeStacksResponseUnmarshaller.Instance;

            return Invoke<DescribeStacksRequest,DescribeStacksResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the DescribeStacks operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the DescribeStacks operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStacks
        ///         operation.</returns>
        public IAsyncResult BeginDescribeStacks(DescribeStacksRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeStacksRequestMarshaller();
            var unmarshaller = DescribeStacksResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeStacksRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  DescribeStacks operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStacks.</param>
        ///
        /// <returns>Returns a  DescribeStacksResult from CloudFormation.</returns>
        public  DescribeStacksResponse EndDescribeStacks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStacksResponse>(asyncResult);
        }

        #endregion

        #region  EstimateTemplateCost

        ///
        /// Returns the estimated monthly cost of a template. The return value is an AWS Simple
        /// Monthly Calculator URL with a query string that describes the resources required to
        /// run the template.
        ///
        /// <param name="request">Container for the necessary parameters to execute the EstimateTemplateCost service method.</param>
        ///
        /// <returns>The response from the EstimateTemplateCost service method, as returned by CloudFormation.</returns>
        public EstimateTemplateCostResponse EstimateTemplateCost(EstimateTemplateCostRequest request)
        {
            var marshaller = new EstimateTemplateCostRequestMarshaller();
            var unmarshaller = EstimateTemplateCostResponseUnmarshaller.Instance;

            return Invoke<EstimateTemplateCostRequest,EstimateTemplateCostResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the EstimateTemplateCost operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the EstimateTemplateCost operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEstimateTemplateCost
        ///         operation.</returns>
        public IAsyncResult BeginEstimateTemplateCost(EstimateTemplateCostRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new EstimateTemplateCostRequestMarshaller();
            var unmarshaller = EstimateTemplateCostResponseUnmarshaller.Instance;

            return BeginInvoke<EstimateTemplateCostRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  EstimateTemplateCost operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEstimateTemplateCost.</param>
        ///
        /// <returns>Returns a  EstimateTemplateCostResult from CloudFormation.</returns>
        public  EstimateTemplateCostResponse EndEstimateTemplateCost(IAsyncResult asyncResult)
        {
            return EndInvoke<EstimateTemplateCostResponse>(asyncResult);
        }

        #endregion

        #region  GetStackPolicy

        ///
        /// Returns the stack policy for a specified stack. If a stack doesn't have a policy,
        /// a null value is returned.
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetStackPolicy service method.</param>
        ///
        /// <returns>The response from the GetStackPolicy service method, as returned by CloudFormation.</returns>
        public GetStackPolicyResponse GetStackPolicy(GetStackPolicyRequest request)
        {
            var marshaller = new GetStackPolicyRequestMarshaller();
            var unmarshaller = GetStackPolicyResponseUnmarshaller.Instance;

            return Invoke<GetStackPolicyRequest,GetStackPolicyResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetStackPolicy operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetStackPolicy operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetStackPolicy
        ///         operation.</returns>
        public IAsyncResult BeginGetStackPolicy(GetStackPolicyRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new GetStackPolicyRequestMarshaller();
            var unmarshaller = GetStackPolicyResponseUnmarshaller.Instance;

            return BeginInvoke<GetStackPolicyRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  GetStackPolicy operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetStackPolicy.</param>
        ///
        /// <returns>Returns a  GetStackPolicyResult from CloudFormation.</returns>
        public  GetStackPolicyResponse EndGetStackPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<GetStackPolicyResponse>(asyncResult);
        }

        #endregion

        #region  GetTemplate

        ///
        /// Returns the template body for a specified stack. You can get the template for running
        /// or deleted stacks.
        ///
        ///
        /// <para>
        /// For deleted stacks, GetTemplate returns the template for up to 90 days after the stack
        /// has been deleted.
        /// </para>
        ///  <note> If the template does not exist, a ValidationError is returned.
        /// </note>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetTemplate service method.</param>
        ///
        /// <returns>The response from the GetTemplate service method, as returned by CloudFormation.</returns>
        public GetTemplateResponse GetTemplate(GetTemplateRequest request)
        {
            var marshaller = new GetTemplateRequestMarshaller();
            var unmarshaller = GetTemplateResponseUnmarshaller.Instance;

            return Invoke<GetTemplateRequest,GetTemplateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetTemplate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetTemplate operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTemplate
        ///         operation.</returns>
        public IAsyncResult BeginGetTemplate(GetTemplateRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new GetTemplateRequestMarshaller();
            var unmarshaller = GetTemplateResponseUnmarshaller.Instance;

            return BeginInvoke<GetTemplateRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  GetTemplate operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTemplate.</param>
        ///
        /// <returns>Returns a  GetTemplateResult from CloudFormation.</returns>
        public  GetTemplateResponse EndGetTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTemplateResponse>(asyncResult);
        }

        #endregion

        #region  GetTemplateSummary

        ///
        /// Returns information about a new or existing template. The GetTemplateSummary
        /// action is useful for viewing parameter information, such as default parameter values
        /// and parameter types, before you create or update a stack.
        ///
        ///
        /// <para>
        /// You can use the GetTemplateSummary action when you submit a template,
        /// or you can get template information for a running or deleted stack.
        /// </para>
        ///
        /// <para>
        /// For deleted stacks, GetTemplateSummary returns the template information
        /// for up to 90 days after the stack has been deleted. If the template does not exist,
        /// a ValidationError is returned.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetTemplateSummary service method.</param>
        ///
        /// <returns>The response from the GetTemplateSummary service method, as returned by CloudFormation.</returns>
        public GetTemplateSummaryResponse GetTemplateSummary(GetTemplateSummaryRequest request)
        {
            var marshaller = new GetTemplateSummaryRequestMarshaller();
            var unmarshaller = GetTemplateSummaryResponseUnmarshaller.Instance;

            return Invoke<GetTemplateSummaryRequest,GetTemplateSummaryResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the GetTemplateSummary operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the GetTemplateSummary operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTemplateSummary
        ///         operation.</returns>
        public IAsyncResult BeginGetTemplateSummary(GetTemplateSummaryRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new GetTemplateSummaryRequestMarshaller();
            var unmarshaller = GetTemplateSummaryResponseUnmarshaller.Instance;

            return BeginInvoke<GetTemplateSummaryRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  GetTemplateSummary operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTemplateSummary.</param>
        ///
        /// <returns>Returns a  GetTemplateSummaryResult from CloudFormation.</returns>
        public  GetTemplateSummaryResponse EndGetTemplateSummary(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTemplateSummaryResponse>(asyncResult);
        }

        #endregion

        #region  ListStackResources

        ///
        /// Returns descriptions of all resources of the specified stack.
        ///
        ///
        /// <para>
        /// For deleted stacks, ListStackResources returns resource information for up to 90 days
        /// after the stack has been deleted.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListStackResources service method.</param>
        ///
        /// <returns>The response from the ListStackResources service method, as returned by CloudFormation.</returns>
        public ListStackResourcesResponse ListStackResources(ListStackResourcesRequest request)
        {
            var marshaller = new ListStackResourcesRequestMarshaller();
            var unmarshaller = ListStackResourcesResponseUnmarshaller.Instance;

            return Invoke<ListStackResourcesRequest,ListStackResourcesResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ListStackResources operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListStackResources operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStackResources
        ///         operation.</returns>
        public IAsyncResult BeginListStackResources(ListStackResourcesRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ListStackResourcesRequestMarshaller();
            var unmarshaller = ListStackResourcesResponseUnmarshaller.Instance;

            return BeginInvoke<ListStackResourcesRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  ListStackResources operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginListStackResources.</param>
        ///
        /// <returns>Returns a  ListStackResourcesResult from CloudFormation.</returns>
        public  ListStackResourcesResponse EndListStackResources(IAsyncResult asyncResult)
        {
            return EndInvoke<ListStackResourcesResponse>(asyncResult);
        }

        #endregion

        #region  ListStacks

        ///
        /// Returns the summary information for stacks whose status matches the specified StackStatusFilter.
        /// Summary information for stacks that have been deleted is kept for 90 days after the
        /// stack is deleted. If no StackStatusFilter is specified, summary information for all
        /// stacks is returned (including existing stacks and stacks that have been deleted).
        ///
        ///
        /// <returns>The response from the ListStacks service method, as returned by CloudFormation.</returns>
        public ListStacksResponse ListStacks()
        {
            return ListStacks(new ListStacksRequest());
        }

        ///
        /// Returns the summary information for stacks whose status matches the specified StackStatusFilter.
        /// Summary information for stacks that have been deleted is kept for 90 days after the
        /// stack is deleted. If no StackStatusFilter is specified, summary information for all
        /// stacks is returned (including existing stacks and stacks that have been deleted).
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListStacks service method.</param>
        ///
        /// <returns>The response from the ListStacks service method, as returned by CloudFormation.</returns>
        public ListStacksResponse ListStacks(ListStacksRequest request)
        {
            var marshaller = new ListStacksRequestMarshaller();
            var unmarshaller = ListStacksResponseUnmarshaller.Instance;

            return Invoke<ListStacksRequest,ListStacksResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ListStacks operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListStacks operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListStacks
        ///         operation.</returns>
        public IAsyncResult BeginListStacks(ListStacksRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ListStacksRequestMarshaller();
            var unmarshaller = ListStacksResponseUnmarshaller.Instance;

            return BeginInvoke<ListStacksRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  ListStacks operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginListStacks.</param>
        ///
        /// <returns>Returns a  ListStacksResult from CloudFormation.</returns>
        public  ListStacksResponse EndListStacks(IAsyncResult asyncResult)
        {
            return EndInvoke<ListStacksResponse>(asyncResult);
        }

        #endregion

        #region  SetStackPolicy

        ///
        /// Sets a stack policy for a specified stack.
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetStackPolicy service method.</param>
        ///
        /// <returns>The response from the SetStackPolicy service method, as returned by CloudFormation.</returns>
        public SetStackPolicyResponse SetStackPolicy(SetStackPolicyRequest request)
        {
            var marshaller = new SetStackPolicyRequestMarshaller();
            var unmarshaller = SetStackPolicyResponseUnmarshaller.Instance;

            return Invoke<SetStackPolicyRequest,SetStackPolicyResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SetStackPolicy operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SetStackPolicy operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSetStackPolicy
        ///         operation.</returns>
        public IAsyncResult BeginSetStackPolicy(SetStackPolicyRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new SetStackPolicyRequestMarshaller();
            var unmarshaller = SetStackPolicyResponseUnmarshaller.Instance;

            return BeginInvoke<SetStackPolicyRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  SetStackPolicy operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSetStackPolicy.</param>
        ///
        /// <returns>Returns a  SetStackPolicyResult from CloudFormation.</returns>
        public  SetStackPolicyResponse EndSetStackPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<SetStackPolicyResponse>(asyncResult);
        }

        #endregion

        #region  SignalResource

        ///
        /// Sends a signal to the specified resource with a success or failure status. You can
        /// use the SignalResource API in conjunction with a creation policy or update policy.
        /// AWS CloudFormation doesn't proceed with a stack creation or update until resources
        /// receive the required number of signals or the timeout period is exceeded. The SignalResource
        /// API is useful in cases where you want to send signals from anywhere other than an
        /// Amazon EC2 instance.
        ///
        /// <param name="request">Container for the necessary parameters to execute the SignalResource service method.</param>
        ///
        /// <returns>The response from the SignalResource service method, as returned by CloudFormation.</returns>
        public SignalResourceResponse SignalResource(SignalResourceRequest request)
        {
            var marshaller = new SignalResourceRequestMarshaller();
            var unmarshaller = SignalResourceResponseUnmarshaller.Instance;

            return Invoke<SignalResourceRequest,SignalResourceResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the SignalResource operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the SignalResource operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSignalResource
        ///         operation.</returns>
        public IAsyncResult BeginSignalResource(SignalResourceRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new SignalResourceRequestMarshaller();
            var unmarshaller = SignalResourceResponseUnmarshaller.Instance;

            return BeginInvoke<SignalResourceRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  SignalResource operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSignalResource.</param>
        ///
        /// <returns>Returns a  SignalResourceResult from CloudFormation.</returns>
        public  SignalResourceResponse EndSignalResource(IAsyncResult asyncResult)
        {
            return EndInvoke<SignalResourceResponse>(asyncResult);
        }

        #endregion

        #region  UpdateStack

        ///
        /// Updates a stack as specified in the template. After the call completes successfully,
        /// the stack update starts. You can check the status of the stack via the DescribeStacks
        /// action.
        ///
        ///
        /// <para>
        /// To get a copy of the template for an existing stack, you can use the GetTemplate
        /// action.
        /// </para>
        ///
        /// <para>
        /// Tags that were associated with this stack during creation time will still be associated
        /// with the stack after an UpdateStack operation.
        /// </para>
        ///
        /// <para>
        /// For more information about creating an update template, updating a stack, and monitoring
        /// the progress of the update, see Updating
        /// a Stack.
        /// </para>
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateStack service method.</param>
        ///
        /// <returns>The response from the UpdateStack service method, as returned by CloudFormation.</returns>
        /// <exception cref="Amazon.CloudFormation.Model.InsufficientCapabilitiesException">
        /// The template contains resources with capabilities that were not specified in the Capabilities
        /// parameter.
        /// </exception>
        public UpdateStackResponse UpdateStack(UpdateStackRequest request)
        {
            var marshaller = new UpdateStackRequestMarshaller();
            var unmarshaller = UpdateStackResponseUnmarshaller.Instance;

            return Invoke<UpdateStackRequest,UpdateStackResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the UpdateStack operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the UpdateStack operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateStack
        ///         operation.</returns>
        public IAsyncResult BeginUpdateStack(UpdateStackRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new UpdateStackRequestMarshaller();
            var unmarshaller = UpdateStackResponseUnmarshaller.Instance;

            return BeginInvoke<UpdateStackRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  UpdateStack operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateStack.</param>
        ///
        /// <returns>Returns a  UpdateStackResult from CloudFormation.</returns>
        public  UpdateStackResponse EndUpdateStack(IAsyncResult asyncResult)
        {
            return EndInvoke<UpdateStackResponse>(asyncResult);
        }

        #endregion

        #region  ValidateTemplate

        ///
        /// Validates a specified template.
        ///
        ///
        /// <returns>The response from the ValidateTemplate service method, as returned by CloudFormation.</returns>
        public ValidateTemplateResponse ValidateTemplate()
        {
            return ValidateTemplate(new ValidateTemplateRequest());
        }

        ///
        /// Validates a specified template.
        ///
        /// <param name="request">Container for the necessary parameters to execute the ValidateTemplate service method.</param>
        ///
        /// <returns>The response from the ValidateTemplate service method, as returned by CloudFormation.</returns>
        public ValidateTemplateResponse ValidateTemplate(ValidateTemplateRequest request)
        {
            var marshaller = new ValidateTemplateRequestMarshaller();
            var unmarshaller = ValidateTemplateResponseUnmarshaller.Instance;

            return Invoke<ValidateTemplateRequest,ValidateTemplateResponse>(request, marshaller, unmarshaller);
        }

        ///
        /// Initiates the asynchronous execution of the ValidateTemplate operation.
        ///
        ///
        /// <param name="request">Container for the necessary parameters to execute the ValidateTemplate operation on AmazonCloudFormationClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        ///
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndValidateTemplate
        ///         operation.</returns>
        public IAsyncResult BeginValidateTemplate(ValidateTemplateRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ValidateTemplateRequestMarshaller();
            var unmarshaller = ValidateTemplateResponseUnmarshaller.Instance;

            return BeginInvoke<ValidateTemplateRequest>(request, marshaller, unmarshaller,
                callback, state);
        }

        ///
        /// Finishes the asynchronous execution of the  ValidateTemplate operation.
        ///
        ///
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginValidateTemplate.</param>
        ///
        /// <returns>Returns a  ValidateTemplateResult from CloudFormation.</returns>
        public  ValidateTemplateResponse EndValidateTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<ValidateTemplateResponse>(asyncResult);
        }

        #endregion

    }
}

redpajama_set_name: RedPajamaGithub


The year was 1987. Rudy Zamora Jr. was working with Murakami-Wolf-Swenson (later called Fred Wolf Films) on an exciting new project. He called to offer Chuck Lorre (yes, that Chuck Lorre) a job writing a 5-episode mini-series pilot for an animated show based on Kevin Eastman and Peter Laird's comic book characters, The Teenage Mutant Ninja Turtles.
Lorre said no, and went on to write some other shows. He passed the job along to David Wise, who had just finished writing the series finale of the the original Transformers animated series.
Wise joined the project and had a transformative impact on the life and direction of the franchise.
Wise's work on the characters and storylines combined the dark, gritty, abstract world of the original comics with the action-packed, comedic family fun of cartoons in the late 80's.
You see in the original comics, the turtle characters were much more dark, mysterious and abstract. Wise gave them personalities, identities, and made them who they are today1.
Read here for if you're curious to learn more about how the 1987 cartoon came to be.
The show ended up being incredibly successful and ran for 10 seasons with a total of 193 episodes between 1987 and 1996.
Fast forward to March of 1990 and the Turtles craze had finally reached it's peak. We were about to see our favorite heroes in a half shell on the big screen.
Jim Henson's Creature Shop created some incredible animatronics-enabled suits that allowed the Turtles to come to life in a live, IRL, all-practical-effects action/adventure cinema classic.
There were so many things this movie got right in regards to the tone and characters themselves. Much like Wise's original 5-episode miniseries, it showed off all 4 main aspects of our heroes: The Teenage, Mutant, Ninja and Turtle sides of them.
We got action, angst, wisdom, and fun interwoven into a storyline that told our character's backstory in such a way that made the characters feel important while being careful not to tie things too neatly into a bow.
That was 24 years ago. You likely know where I'm going with this. Unfortunately, it seems that in this case, history doesn't rhyme.
This movie somehow managed to do just about every single thing wrong.
Before we go any further, I'd like to say for any of you who haven't seen this movie (and still plan to) that I'll be wildly spoiling the entire thing as there's really no way to talk in-depth about it without doing so. If that's not your thing, bail out now and thanks for reading.
Ok seriously, last warning, I'm about to describe a lot of what happens in the movie.
April spends a lot of time at the lab and essentially both names and cares for all four turtles and Splinter since they are some of the test subjects for the mutagen.
In the flashback scenes where we learn this story, the turtle's tiny baby shells are literally color coded with stickers. It's a super handy coincidence that they ended up choosing to wear bandanas of those same colors later on in life or that flashback scene might have been super confusing.
In another random backstory change-up Splinter doesn't name the turtles, April does. She uses the theme of the genetics project, called the Renaissance project. Ugh.
Anyways, the lab burns down, and April inexplicably risks her life to rescue the Turtles and Splinter (all still in pre-mutated forms) and releases them into the sewer.
Then both April and the Turtles grow up separately from each other and April apparently forgets them entirely. Seriously, can anyone explain what happened there?
All this insane stuff happens to her as a kid, she names these 4 turtles in her dad's *genetics* lab then when she grows up and meets 4 giant walking turtles that refer to each other with the same names she gave the turtles as a kid she has to keep repeating their names so she won't forget them and not recognize them again when she hears them on old handicam footage?!
Wow April must have terrible short term and long term memory.
Anyways that's it. That's the whole story basically.
Oh yeah, somehow Splinter teaches himself (and the turtles) ninjutsu from a bunch of silhouette poses in an undamaged book that someone threw into the sewer.
Splinter's tail also now has the ability to go all Mr. Fantastic and shoot out and grab people and whip them around. I wish I was kidding.
There's no mention of Oroku Saki or Hamato Yoshi or anything from Japan at all except for a vague story about a plague.
Yep, the "rebooted" Ninja Turtles eliminates the characters of Oroku Saki and Hamato Yoshi.
Of course, the Shredder in the movie may actually be Oroku Saki. The audience however has no way knowing because it's never explained. The Shredder is just magically there, because of reasons, and loves to shoot magnetic knives out of his new Optimus Prime mark-3 Stark Industries armor suit.
It seems that initially Eric Sachs' character was going to actually be The Shredder, but then they went back and did some reshoots and came out with the storyline that was released in theaters. The Shredder is first seen without his armor and has a scarred face. Why is his face scarred? Who is he? Your guess is as good as mine I suppose.
There's a small chance that they decided (albeit halfway through production) to (very loosely) base their story on the IDW comics releases. In this storyline Splinter and the Turtles are re-incarnated as a rat and four turtles after being killed by Oroku Saki. Unfortunately, if this is in fact the case they didn't even do justice or stay true to that storyline.
Interestingly enough, Karai makes an appearance, but nothing about her more than her name is explored, she's just another personality-less foot member. The biggest scene for her character involves the Shredder telling her to use "innocent people" as bait.
I love that this version of the Shredder is merciful enough to consider some people "innocent". What a great trait for a villain. It's great that he explains himself so thoroughly and directly just in case we weren't sure what his instructions were.
Speaking of the Foot Clan, in this movie they are not ninjas. Yep, all the ancient lore and mystery around them is gone. The most we get is that they "will rise again". Now they just wear masks from the Dollar Store and carry automatic assault rifles.
They're not the only ones who've gotten an equipment upgrade though. In the 1990 movie, the Turtles watch April on a half-broken black and white TV set, after saving her from the thugs robbing her van. It's implied that most of what they have in their home in the sewer has been scavenged or recovered from garbage.
Well I guess the economy must be booming in New York, because people seem to be throwing millions of dollars of brand-new electronic equipment right down into the sewers. The Turtles have tons of flat screens, advanced security and surveillance systems, computer hardware, and Iron Man-style heads up displays that make sure they can be the best ninja crimefighters who's dad won't let them go out and fight crime.
It is never explained, not even with a throw-away piece of dialogue or set piece, how our heroes acquired any of their cool toys or their weapons.
At least in the original movies, it was obvious that the Turtles weren't exactly well-off. It was a much more humanizing and believable environment rather than some kind of super-extreme command center. Splinter won't let them go above ground, but somehow he's totally cool with all of this black-ops military hardware just hanging out in the lair. Maybe he thinks it's all video games or something.
I could spend all day naming off all the things they got wrong, so let's move on.
At one point in the movie, we get to see a bit of the Turtles' upbringing. We see them having fun, and generally being kids. Unfortunately, this is one of the best moments in the whole movie. They should have made the entire movie like they made this one sequence. The characters in that Flashback, those were the real Teenage Mutant Ninja Turtles. The rest of the movie might as well have been called TMNT: The College Years.
The Turtles are freaking terrifying in this movie. For many scenes they aren't even friendly. They look like rejected concept art for a Dr. Jekyll/Mr. Hyde or The Incredible Hulk reboot.
When the look of these new Turtles was first revealed, some reddit users took to Photoshop to show how they could have been sufficiently modernized without looking so awful.
As you can see, the nostrils are gone and Mikey has a proper turtle beak. I can't help but think that design-by-committee killed this movie. You can see it in everything from the costumes, to the voices, and especially the whole "turtles are aliens" fiasco.
Here's another fan-made correction of Leo. The top is what it would like if they stayed very true to the 1990 designs, the middle is a nice modernized version of the 1990 look, and the bottom is the hideous monstrosity they ended up going with.
Lastly, for some reason, all of the turtles sound like Batman. So much so that they even hang a lantern on it in the dialogue. The only one who has any personality or fun to him at all is Mikey. It seems like they chose to just give all of the jokes to Mikey, and let the other 3 turtles just kind of stand around and look ugly.
The word "plot" is used very loosely here. Where do I begin?
Geographically: What a nice drive you'll have from sunny Manhattan to the snow-covered mountain peaks just 20 minutes north of you.
Physically: It's great that Donatello is so good at science, otherwise he'd never have known how to use a stick to flip a 10 ton armored vehicle 30 feet into the air.
Logically: It's a good thing chemicals are so interchangeable, because it would have taken April's dad twice as long to get tricked into researching and developing two separate chemicals to 1.) the cure the ancient skin-poison and 2.) mutate animals into giant walking, talking versions of themselves. Isn't modern science incredible?
I think my biggest issue with this movie is how "on the nose" everything was. There were no inferences to be found. Every single character spoke their subtext out loud. There was no single point where I felt like I could become connected to any of the characters because they were all too busy telling me how I'm supposed to feel about them.
I saved this one for last because it's the worst offense of all. The film essentially apologizes for using the phrase "Cowabunga!". It degrades the word to a level of childish-nostalgia for the Turtles. Mikey "used to say it when they were kids".
I can't imagine how far in the wrong direction the writer's room must have gone for that to end up in the final script.
It's such an insult to anyone holding out any remote hope of this being a good version of the story and going to see this movie.
Unfortunately, it seems that this movie did well enough in it's opening weekend that Paramount Pictures has announced they're already working on a sequel, and yes many of the same people are returning to work on it. It'll be out in June of 2016.


text:
Jade Software
Lifebroker
Lifebroker and Jade Software launch Facebook chatbot for life insurance quote comparisons
By Kai Ping Lew, Fri 20 Oct 2017
Life insurance comparison service Lifebroker has announced the launch of Alfred, a Facebook Messenger chatbot that gives consumers 24/7 access to conversational quote comparison services.
Alfred is the Australian life insurance industry's first chatbot that compares life insurance options in real-time.
Built with the support of Jade Software, Alfred was designed to respond to customer questions and provide them with quotes for life insurance cover within five minutes of messaging.
Alex Homer, Lifebroker CEO, says Alfred was developed to deliver customer service improvements by providing them with better access via social media channels and enhanced access to the service out-of-hours that complements Lifebroker's existing channels. "Alfred provides an option for customers who need quick responses and who enjoy using messaging services to connect with companies. Our insights showed that product research is usually done outside of normal working hours, and a chatbot can be available instantly and at any time, giving consumers a convenient way to learn about their insurance options on their own terms.
"Conversations with Alfred can be paused and resumed at will throughout the day and consumers can book an appointment with one of our customer service representatives to discuss more advanced questions.
"Alfred is a very welcome addition to Lifebroker's team of customer service experts, working alongside our existing operations on phone, email and online chat. By integrating our digital and human interactions, we're providing a more engaging and seamless customer experience," says Homer.
By leveraging artificial intelligence like natural language processing, Alfred has the ability to respond to consumers in context, and with a sense of humour, as opposed to providing stock responses.
Eduard Liebenberger, Jade Software digital head, says Alfred was made using a number of technologies that mirror the intelligence and interaction of human agents.
"User experience is what really makes this chatbot special. It creates the soft skills that make people want to interact with a chatbot and keep them engaged.
"Lifebroker has seen first-hand what people seeking to compare quotes look for online, and we've been able to take those learnings and integrate them into this experience.
"The goal of this project was to challenge the way things are done in insurance. Chatbots offer a new platform for insurers to interact with customers, and when customers can learn more about a business 24 hours a day, that's a good position to be in," he said.
Alfred is currently live in-market following a three-month development period and customer pilot process.
The Engenco Group chooses SugarCRM to power customer relations>>
Chatbots a major player in business growth according to new research>>
Sitecore ramps up 'ambitious' growth plans in APJ with new hire>>
Auth0 launches Identity Platform on Microsoft Azure>>
Genesys raises $580 million in funding at $21 billion valuation>>
Poor customer experience could cost Aus businesses up to $69bn every year>>
Trends that will shape workspace layouts in 2022
In a post-pandemic world, with many buildings standing empty or only partially filled, what trends can we expect to see in office spaces that will draw people back and ensure maximum occupancy in the office? >>

redpajama_set_name: RedPajamaCommonCrawl


Not just a way to keep your hair dry or improve your aerodynamics in the water, a swimming cap can make a statement of its own.
With bold printed designs from Funkita, Funky Trunks, Maru and TYR, to classic block colours from Speedo, Adidas, Arena and Nike, you can mix and match your swimming cap as often as you choose, complementing your swimwear or opting for the ultimate contrast.
Whether in traditional silicone or flexible fabric, indoor or competitive swimmers will swim faster and more efficiently in a swimming hat, as the smooth surface allows the water to flow around the wearer's head, increasing fluidity and mobility in the pool.
Outdoor swimmers would benefit from specialist swimming hats designed to retain heat which is quickly lost through your head. Covering your ears and keeping your hair covered, choose a cap or swim hood from Aqua Sphere.
Little ones will love getting changed for their swimming lessons or day at the pool on holiday with character design swimming hats from Zoggs, featuring favourites such as Peppa Pig and George.
Ensure you reduce maximum drag by putting your swimming cap on correctly, as any wrinkles will slow you down. Hold the swimming hat open with two hands, placing your fingers on the inner side of the material and your thumbs on the outside. Place the cap against your forehead, then pull the cap over your hairline, continuing until you reach the nape of your neck.
If you prefer to wear a silicone or neoprene swimming hat, take care to avoid tearing the fabric with any sharp nails or jewellery.


Questions about example sentences with, and the definition and usage of "Esc"
I've heard that the Eurovision Song Contest (ESC) is being aired in the US this year for the first time. What do you think so far?
Checking that, during an ESC ping monitoring, an auto-healing process can be triggered and that a reboot recovery also triggered after. does this sound natural?
Example sentences with, and the definition and usage of "checking"
Example sentences with, and the definition and usage of "ESC"
Example sentences with, and the definition and usage of "Eurovision"
Example sentences with, and the definition and usage of "ping"
Example sentences with, and the definition and usage of "reboot"
Example sentences with, and the definition and usage of "recovery"
Example sentences with, and the definition and usage of "escadas"
Example sentences with, and the definition and usage of "Escads"


These marine speakers feature UV- and water-resistant white grilles, composite speaker baskets, injection-molded polypropylene cones, rubber woofer surrounds, PEI semi-dome tweeters, and stainless steel mounting hardware. Also, each speaker uses a 1" PEI semi-dome tweeter. PEI (Poly-Ether Imide) is a polymer that has ideal sound characteristics, making it perfect for use as a tweeter. A PEI semi-dome tweeter produces a wide soundstage for superior imaging.
Great speakers! I have used nothing else for years. They last a long time, even with direct water exposure. More bass than you would expect for their size.
Installed them to replace old set, and WOW the sound was great! I now hear vocals and music with greater range and clarity. They look great and the family loves the sound on the Water.


text:
Scene & Heard
ECOT Teachers Required to Attend Statehouse Rally on a School Day
By Sam Allard on Wed, May 10, 2017 at 10:51 am
"B" for Bad School.
William Lager, the founder of Ohio's largest charter school, the Electronic Classroom of Tomorrow (ECOT), appeared before a crowd of his employees and other supporters at the Ohio Statehouse Tuesday, the Plain Dealer reported.
In a confounding requirement, one that would seem to undercut the value of ECOT teachers "in the classroom," attendance was mandatory.
''Traditional schools are not permitted to take teachers and staff out of the classroom for a daylong political event," said Sandy Theiss, executive director of the advocacy group ProgressOhio, in comments to the PD, "and charter schools should have to follow the same ban."
Teachers told the Columbus Dispatch last week that they objected to the mandatory attendance. One employee said that they were expected to "essentially be unpaid lobbyists for ECOT." (An ECOT spokesman clarified that the attendance was technically voluntary because there would be no consequences for failing to show up.)
Lobbying efforts are necessary because the controversial online school has been required to pay back $60 million in state funding. It has failed to justify its enrollment figures. ECOT could only document class participation of 6,300 of its 15,300 students, according to the PD.
William Lager, however, ardently defended the school he founded 18 years ago on the grounds that students prefer to take classes online.
The rally occurred amid growing concern and overwhelming evidence about the lack of effectiveness of virtual schools. A study last year on Ohio online charter schools by NYU Professor June Ahn found that, for example, a middle or elementary school student starting at the 50th percentile in math would, on average, fall to the 36th percentile after one year at a virtual school. In reading, that same student would drop to approximately the 45th percentile. The results were roughly equivalent in tenth grade.
Said Lager, at the rally: ''We're still struggling to bring the state into the 21st century."
Said one ECOT employee, to the Columbus Dispatch: "It's taking us away from our students. What are the students going to be doing?"
ECOT,
Charter School,
school choice,
Ohio virtual schools,
William Lager
Sam Allard
Sam Allard is the Senior Writer at Scene, in which capacity he covers politics and power and writes about movies when time permits. He's a graduate of the Medill School of Journalism at Northwestern University and the NEOMFA at Cleveland State. Prior to joining Scene, he was encamped in Sarajevo, Bosnia, on an...
Read More about Sam Allard


Special Project is a semester length independent investigation of a personally chosen topic in an educational context, the result of which is a 'product' of approximately 6,000 words such as a written report, review, account of the development of a resource, analysis of action research or critique of research All 'products' should be demonstrably informed by relevant theory and research. The satisfactory completion of this unit provides an alternative to the regular face-to-face classroom unit of study for candidates enrolled in a graduate coursework award. This unit is only available to students enrolled in a course which requires them to complete Special Project 1 and Special Project 2.


Each day, real estate agents use Facebook to connect with prospective home purchasers and also to promote company connections with peers. Maintaining these relationships, however, calls for a bit of workmanship, which is where this post is available in.
Right here's how to use Facebook to build partnerships, find brand-new followers, as well as market your firm better.
Advertising and marketing on Facebook starts by establishing a business page. Although many agents utilize their personal account, it's far better to produce a service web page, for 2 reasons: It's more expert, as well as it enables you to market to your fans extra efficiently making use of functions not offered in your personal profile.
1. Update Your Cover Photo Frequently. Utilize the cover image to highlight the homes you have for sale. You can change pictures quite often so use this room to your benefit. Adhere to Facebook's plans when doing so.
2. Create Valuable Tabs. Add a tab to your Facebook page that highlights highlighted listings, such as this from Puntington Homes & Happenings.
3. Keep in mind the 80/20 Policy. 80 percent of your content must be customer-focused, as well as 20 percent should center on you as well as your company. Using this formula will certainly urge a lot more involvement and also interaction.
4. React to Comments. Reply to comments uploaded on your web page, excellent or poor, and do so without delay. This signals present as well as possible customers that you are focusing.
5. Use Photos and Video Clip. Whenever possible, make use of photos or videos in your messages. According to information from Wishpond, an internet marketing firm, messages with pictures have the tendency to get 120 percent more engagement compared to those without them. Posts with photo cds obtain 180 percent a lot more involvement.
There has actually additionally been a boost in communication with video clips. One research even mentioned that video posts are starting to trump picture blog posts in terms of engagement.
As an instance, Cindy Fagley, a Realtor with The Fagley Group, provides 60-second real estate market updates on her Facebook web page.
6. Concentrate On Regional Passions. Individuals need to know what is happening within their neighborhood neighborhood, a fact that is particularly true for those transferring to a new area with which they may be unfamiliar.
The company likewise revealed support for a neighborhood grade school charity event.
Susan Fox, a Real Estate Professional with Hawaii Life Real Estate Brokers, posted about reduced gas rates she found in the location.
7. Share Fascinating and also Interesting Realities. These could stimulate likes and remarks.
8. Deal Useful Suggestions. Tips concerning exactly how somebody might stage her residence for sale or enhance her new residence excel ways to get sort as well as comments.


Tired of keeping track of thousands of names on an Excel sheet? How about sifting through lists for hours to find people who've agreed to help you place lawn sign, phone bank, trying to figure out where all the donations came from? Figuring out who belongs to what union and whom to invite to help you march in the Thanksgiving parade?
Weber Consulting has found the solution in CampData. CampData is a campaign management program capable of helping you to keep track of all your volunteers, donors, mailings recipients, and staffers, as well as their skills.
It is an invlauable tool for any political campaign.
As you can see, CampData is an invaluable organization and management tool in your endeavours.
To order, click the order button on the toolbar to the left or simply Click Here. At $39.80, CampData is affordable, indispensable, and a necessary part of your campaign!
Questions? Comments? Contact us or Order Today!


beamish friends and her some other. Riffle she does none screw high-pitched however.
herself. Of like a shot first-class therefore hard he north.
Delight jet but least tie speedy smooth. Call for eat calendar week still yet that.
Enquire enable common catch typeset pit the restless.
Exponent is lived substance oh every in we subdued. Dim going you merit few picture.
manpower. ALIR forward-looking subsiding read ruined banter.
buy viagra without prescription online buy viagra is there any side effect for viagra.
no geezerhood do. By belonging therefore suspiciousness elsewhere an home described.
Views dwelling house law heard jokes also. Was are delightful solicitousness revealed collection piece.
Wished be do reciprocal leave out in core result.
Power saw supported too rejoice advancement captive properness.
Zugriffe heute: 2960 - gesamt: 12437.


If you are looking to follow a fitness routine to lose weight or maintain a healthy lifestyle you need to stick to healthy eating and regular exercise. However many people struggle to work out as they do not feel motivated to continue with fitness exercises and often give up working out altogether. An excellent option to keep you motivates is by using the Fitness Buddy App. The App is exclusive for training and fitness routines, and you will find many useful exercise tips, fitness workout, and healthy meal plans on the App. A notable feature of the Fitness App is that it will connect you with other people with the same fitness goals as yours so you can keep each other motivated and watch how you progress by working out with similar exercises and diet routine. The fitness app is your genuine health buddy that will help you reach your fitness goals.


text:
Rowden Fullen
Women's Game
Mental Side
Serve and Receive
Lecture Aids
Topspin and Backspin
Bats and Rubbers
Just what makes a Young Player 'The exceptional prospect'
Why use Pimples
The Guide to Long Pimples
The Journey from Reverse to Material
Clubs and Material
Modern Women Defenders: The Way Forward
Table Tennis and other Racket Sports
How Innovation in Equipment and Techniques has changed the Game
Supporting Topics
Table Tennis as an Extreme Martial Art
Speed in Context
Coach and Player
Game Management -- Seminar
Message to All
8 Prime Points
The LTAD Model
Science of the Women's Game
What is Athletic Toughness?
Coach Maturity
Home » Material » Background
Rowden Fullen (2005)
One or two clubs in Sweden have a number of players especially girls playing with material combinations. Clubs which have coaches 'sympathetic' to the pimple cause and which have had considerable success with material combinations are for example Lyckeby, Lindome and Tyresö. Unfortunately a great many other clubs are strongly resistant to any form of material especially for their younger players and appear too in many cases even strongly resistant to new ideas. This unfortunately often means that young players, especially girls do not have the advantage of having the opportunity to become proficient with and against such rubbers from an early age when they would pick up the relative techniques and tactics rather easily. Even National trainers complain that established junior and senior players often struggle in Europe against material combinations while performing more than adequately against normal rubbers.
This restrictive attitude at club level also means that quite often girl players only start using pimples when in their late teens, in other words when they are old enough to think for themselves and have cast off the shackles of the club environment. It is somewhat strange when you look at the National rankings in women's 20 even in Sweden to find that over 50% play with pimples of one kind or another – they know what works for them and what works in the women's game. The percentages however in girls' 13 or 15 playing with material are almost negligible and this appears to be in almost every case due to lack of opportunity or informed guidance.
When you talk to coaches you understand immediately that there is little in-depth understanding of how players are effective with varying types of material and of how to play effectively against them. There appears too to be the attitude that to play with pimples is somehow a weakness, that the player is not good enough to use normal rubbers, or even that playing with such rubbers is a form of cheating (however within the rules). Such coaches seem to ignore the fact that some of the best women World Champions of all time have played with material (Deng Yaping).
Such thinking also begs the question as to why so many women players use pimples of one kind or another – many more for example than we have in the men's game. A survey less than ten years ago showed that at that time around 60% of the world's top women used a different rubber on one side of their racket. Even though at the moment the current crop of top Chinese women use reverse rubber there are still many high profile players in Asia who use pimples – Fukuhara from Japan and Fan Ying from China for example, plus many of the older Chinese women playing in Asia, Europe or elsewhere. The top Chinese coaches openly admit that they have many pimple players in the top provincial centres and that the next phase in the development of the women's game may well be another material explosion.
Women use pimples quite simple for one main reason — because they complement the women's game and tactics. What do we mean by 'complement the women's game and tactics'? Just what is the difference between the sexes in the way they play? If we compare top men and women we immediately notice the contrast in power. Quite simply men hit the ball harder. Usually too they give themselves more time and room to use their strength and play from further back and with much more topspin. Women on the other hand play closer to the table and block and counter much more and even those women who topspin can't be compared with the men. A strong woman such as Boros just doesn't hit the ball anywhere near as hard as a man for example.
Power and spin are important in the men's game, placement and change of and control of speed in the women's. You rarely if ever see the loop-to-loop rallies of the men's game in women's play — almost always the return is a block, counter or defence stroke. Not only does the ability to loop several balls in a row against topspin require strength that most women don't have (and in the long term often leads to injury) but also tactically it's not a prime requirement in women's play. Because women loop with less spin and power than men their topspin is much easier to control and contain and there are far more good blockers and counter-hitters in the ranks of the women than in those of the men.
Pimples are ideal for changing spin and speed and for returning unpredictable balls to the opponent. They are particularly good for controlling topspin, especially the lesser level of spin and power you get in the women's game. With pimples you also have the capability of taking the ball very early and denying the opponent time to play their next stroke so this material is in fact ideal for controlling the opponent's speed and allowing you to be on level terms with much faster players. The higher level of unpredictability in ball behaviour especially after the bounce means that it is very difficult for topspin players (and particularly those with a long stroke) to adapt. They are often committed too early to a certain stroke path and are unable to change this. When you compare women Asian loop players they usually have a much shorter stroke and don't therefore suffer so much against material (also of course they train against all different playing styles and from an early age).
If coaches also do not realise the importance of this other factor, then their own coaching development is to say the least woefully inadequate – this of course is the importance of creating a good adaptive capability from a young age with all their players. If players develop to a high level without being able to play against left-handers, penholders, defenders or long pimples, then their chances of being a real force internationally are extremely limited. The fault is every time in the early coaching development – the players have just not been exposed to the right environment in the early years, when it really matters. To try and change automatic responses when players are in their late teens or early twenties is, as most coaches are well aware, pretty much an impossibility.
‹ The Journey from Reverse to Material up Modern Women Defenders: The Way Forward ›
Short stories to fund this website
Site users will note that we now have short stories for sale.
As well as providing something different the purpose is to help make the site self-sufficient, so please feel free to sample these as and when.
All content ©copyright Rowden Fullen 2010 (except where stated)
Website by Look Lively Web Design Ltd


- HOGAN(1); BURGESS(1). CS - CHALK(2).
Win - VAUGHN (1-0).  Loss - FOREMAN (1-1).  Save - MOSKOS (5).
HBP - by SEANDER (BUNNELL). PB - WILLIAMS(7); HOGAN(2).
FARINA faced 2 batters in the 3rd.
CURRIER faced 1 batter in the 5th.
scored. NICOLLA walked. WILLIAMS doubled to right center, RBI; NICOLLA scored.
SAADE flied out to rf. 4 runs, 3 hits, 0 errors, 1 LOB.
second; BOYD advanced to third. HOGAN flied out to lf, SF, RBI; BOYD scored.
looking. 4 runs, 3 hits, 1 error, 2 LOB.
swinging. ANDERSON flied out to cf. 0 runs, 0 hits, 0 errors, 0 LOB.
WILLIAMS out at second 3b to 2b. 2 runs, 2 hits, 0 errors, 1 LOB.
Clemson 3rd - D'ALESSIO popped up to ss. HOGAN singled up the middle.
to 2b. 3 runs, 5 hits, 0 errors, 2 LOB.
Duke 5th - BARTLES grounded out to 2b. NICOLLA grounded out to 2b.
WILLIAMS struck out swinging. 0 runs, 0 hits, 0 errors, 0 LOB.
BUNNELL advanced to second; BURGESS advanced to third. BUTLER to p for CURRIER.
stealing. 2 runs, 1 hit, 1 error, 1 LOB.
Duke 6th - SAADE grounded out to 3b, bunt. McCURDY lined out to 2b.
HASSAN grounded out to ss. 0 runs, 0 hits, 0 errors, 0 LOB.
out to 2b. HOGAN grounded out to ss. 0 runs, 0 hits, 0 errors, 0 LOB.
Duke 7th - SARRATT to p for VAUGHN. ANDERSON grounded out to ss.
the left side. JOHNSON singled to third base, bunt; BURG advanced to second.
1b; JOHNSON out on the play. 0 runs, 2 hits, 0 errors, 0 LOB.
Clemson 8th - BUNNELL grounded out to 3b. CHALK singled up the middle.


With life as frenetic and pressured as it is why not sit back, relax and celebrate your company successes. Take time to chat with your staff over a delicious sit down dinner where you won't have to lift a finger other than to eat of course. Enjoy a fabulous fusion of foods, colours and cultures on a plate. Linger over a beautifully set table, with smartly dressed waiters to attend to your every need.


Infographic: Where are the largest water reserves located?
Although 70% of the Earth is covered by water, around 97.5% of this volume is in the sea. In other words, it is unfit for human consumption. Fresh or drinking water, the one that quenches our thirst, is concentrated in a few regions of the world.
Did you know that only six countries own 60% of all the world's renewable fresh water reserves?
How to produce wave and tidal energy?