<?xml version="1.0"?>
<wsdl:definitions
  targetNamespace="http://elasticloadbalancing.amazonaws.com/doc/2011-08-15/"
  xmlns:tns="http://elasticloadbalancing.amazonaws.com/doc/2011-08-15/"
  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
  xmlns:wsa="http://www.w3.org/2005/08/addressing/"
  xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <wsdl:types>

    <xs:schema
      targetNamespace="http://elasticloadbalancing.amazonaws.com/doc/2011-08-15/"
      elementFormDefault="qualified">

      <xs:element name="ResponseMetadata">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="RequestId" type="xs:string"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="Error">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="Type">
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:enumeration value="Receiver"/>
                  <xs:enumeration value="Sender"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="Code" type="xs:string"/>
            <xs:element name="Message" type="xs:string"/>
            <xs:element name="Detail">
              <xs:complexType>
                <xs:sequence>
                  <xs:any maxOccurs="unbounded" minOccurs="0" namespace="##any" processContents="lax"/>
                </xs:sequence>
                <xs:anyAttribute namespace="##other" processContents="lax"/>
              </xs:complexType>
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="ErrorResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:Error" maxOccurs="unbounded"/>
            <xs:element name="RequestId" type="xs:string"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="ConfigureHealthCheck">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
              	<p>
              	Input for the <a>ConfigureHealthCheck</a> action.
              	</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The mnemonic name associated with the LoadBalancer.
                      This name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="HealthCheck" type="tns:HealthCheck">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A structure containing the configuration information
                      for the new healthcheck.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="ConfigureHealthCheckResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:ConfigureHealthCheckResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="ConfigureHealthCheckResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
                	<p>
                	The output for the <a>ConfigureHealthCheck</a> action.
                	</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="HealthCheck" type="tns:HealthCheck" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The updated healthcheck for the instances.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesForBackendServer">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string"/>
            <xs:element name="InstancePort" type="xs:integer"/>
            <xs:element name="PolicyNames" type="tns:PolicyNames"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesForBackendServerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:SetLoadBalancerPoliciesForBackendServerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesForBackendServerResult">
        <xs:complexType>
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerListenerSSLCertificate">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>SetLoadBalancerListenerSSLCertificate</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The name of the the LoadBalancer. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="LoadBalancerPort" type="xs:integer">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The port that uses the specified SSL certificate. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="SSLCertificateId" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The ID of the SSL certificate chain to use. 
                 	For more information on SSL certificates, see 
                 	<a href="http://docs.amazonwebservices.com/IAM/latest/UserGuide/ManagingServerCerts.html">
                 	Managing Server Certificates
                 	</a>
                 	in the AWS Identity and Access Management documentation. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerListenerSSLCertificateResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:SetLoadBalancerListenerSSLCertificateResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerListenerSSLCertificateResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>SetLoadBalancerListenerSSLCertificate</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="RegisterInstancesWithLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>RegisterInstancesWithLoadBalancer</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Instances" type="tns:Instances">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of instances IDs that should be registered with the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="RegisterInstancesWithLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:RegisterInstancesWithLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="RegisterInstancesWithLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>RegisterInstancesWithLoadBalancer</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="Instances" type="tns:Instances" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      An updated list of instances for the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesOfListener">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>SetLoadBalancerPoliciesOfListener</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="LoadBalancerPort" type="xs:integer">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The external port of the LoadBalancer with which this policy has to be associated. 
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="PolicyNames" type="tns:PolicyNames">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      List of policies to be associated with the listener. Currently this list can have at most
                      one policy. If the list is empty, the current policy is removed from the listener.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesOfListenerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:SetLoadBalancerPoliciesOfListenerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="SetLoadBalancerPoliciesOfListenerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>SetLoadBalancerPoliciesOfListener</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerListeners">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DeleteLoadBalancerListeners</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The mnemonic name associated with the LoadBalancer. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="LoadBalancerPorts" type="tns:Ports">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                  The client port number(s) of the LoadBalancerListener(s) to be removed. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerListenersResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DeleteLoadBalancerListenersResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerListenersResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DeleteLoadBalancerListeners</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLBCookieStickinessPolicy">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>CreateLBCookieStickinessPolicy</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="PolicyName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name of the policy being created. 
                      The name must be unique within the set of policies for this Load Balancer.    
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="CookieExpirationPeriod" type="xs:long" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The time period in seconds after which the cookie should be considered stale. 
                      Not specifying this parameter indicates that the sticky session will last for the duration 
                      of the browser session. 
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLBCookieStickinessPolicyResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:CreateLBCookieStickinessPolicyResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLBCookieStickinessPolicyResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>CreateLBCookieStickinessPolicy</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPolicies">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string" minOccurs="0"/>
            <xs:element name="PolicyNames" type="tns:PolicyNames" minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPoliciesResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DescribeLoadBalancerPoliciesResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPoliciesResult">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="PolicyDescriptions" type="tns:PolicyDescriptions" minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPolicyTypes">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="PolicyTypeNames" type="tns:PolicyTypeNames" minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPolicyTypesResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DescribeLoadBalancerPolicyTypesResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancerPolicyTypesResult">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="PolicyTypeDescriptions" type="tns:PolicyTypeDescriptions" minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DisableAvailabilityZonesForLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DisableAvailabilityZonesForLoadBalancer</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of Availability Zones to be removed from the LoadBalancer.
                      </p>
                      <note>
                      There must be at least one Availability Zone
                      registered with a LoadBalancer at all times.
                      The client cannot remove all the Availability Zones from a LoadBalancer.
                      Specified Availability Zones must be in the same Region.
                      </note>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DisableAvailabilityZonesForLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DisableAvailabilityZonesForLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DisableAvailabilityZonesForLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DisableAvailabilityZonesForLoadBalancer</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of updated Availability Zones for the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
              	<p>
              	The input for the <a>CreateLoadBalancer</a> action.
              	</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within your set of LoadBalancers.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Listeners" type="tns:Listeners">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of the following tuples:
                      LoadBalancerPort, InstancePort, and Protocol.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of Availability Zones.
                      </p>
                      <p>
                      At least one Availability Zone must be specified.
                      Specified Availability Zones must be in the same EC2 Region
                      as the LoadBalancer.
                      Traffic will be equally distributed across all zones.
                      </p>
                      <p>
                      This list can be modified
                      after the creation of the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:CreateLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>CreateLoadBalancer</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="DNSName" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The DNS name for the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="EnableAvailabilityZonesForLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>EnableAvailabilityZonesForLoadBalancer</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of new Availability Zones for the LoadBalancer.
                      Each Availability Zone must be in the same Region as the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="EnableAvailabilityZonesForLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:EnableAvailabilityZonesForLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="EnableAvailabilityZonesForLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>EnableAvailabilityZonesForLoadBalancer</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      An updated list of Availability Zones for the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerPolicy">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string"/>
            <xs:element name="PolicyName" type="xs:string"/>
            <xs:element name="PolicyTypeName" type="xs:string"/>
            <xs:element name="PolicyAttributes" type="tns:PolicyAttributes" minOccurs="0"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerPolicyResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:CreateLoadBalancerPolicyResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerPolicyResult">
        <xs:complexType>
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeregisterInstancesFromLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DeregisterInstancesFromLoadBalancer</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Instances" type="tns:Instances">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of EC2 instance IDs consisting of all
                      instances to be deregistered.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeregisterInstancesFromLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DeregisterInstancesFromLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeregisterInstancesFromLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DeregisterInstancesFromLoadBalancer</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="Instances" type="tns:Instances" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      An updated list of remaining instances
                      registered with the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateAppCookieStickinessPolicy">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>CreateAppCookieStickinessPolicy</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="PolicyName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name of the policy being created. 
                      The name must be unique within the set of policies for this Load Balancer.    
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="CookieName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Name of the application cookie used for stickiness. 
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateAppCookieStickinessPolicyResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:CreateAppCookieStickinessPolicyResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateAppCookieStickinessPolicyResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>CreateAppCookieStickinessPolicy</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancer">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DeleteLoadBalancer</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DeleteLoadBalancerResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DeleteLoadBalander</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerPolicy">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DeleteLoadBalancerPolicy</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The mnemonic name associated with the LoadBalancer. 
                 	The name must be unique within your AWS account.
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="PolicyName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The mnemonic name for the policy being deleted. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerPolicyResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DeleteLoadBalancerPolicyResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DeleteLoadBalancerPolicyResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DeleteLoadBalancerPolicy</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeInstanceHealth">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
                  <p>
                  Returns the current state of the instances of the
                  specified LoadBalancer. If no instances are specified,
                  the state of all the instances for the LoadBalancer is returned.
                  </p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      The name associated with the LoadBalancer.
                      The name must be unique within the client AWS account.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Instances" type="tns:Instances" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of instance IDs whose states are being queried.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeInstanceHealthResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DescribeInstanceHealthResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeInstanceHealthResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DescribeInstanceHealth</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="InstanceStates" type="tns:InstanceStates" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list containing health information
                      for the specified instances.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancers">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>DescribeLoadBalancers</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerNames" type="tns:LoadBalancerNames" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of names associated with the LoadBalancers at creation time.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancersResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:DescribeLoadBalancersResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="DescribeLoadBalancersResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>DescribeLoadBalancers</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
            <xs:element name="LoadBalancerDescriptions" type="tns:LoadBalancerDescriptions" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      A list of LoadBalancer description structures.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerListeners">
        <xs:complexType>

          <xs:annotation>
            <xs:documentation><![CDATA[
          		<p>
          		The input for the <a>CreateLoadBalancerListeners</a> action.
          		</p>
              ]]></xs:documentation>
          </xs:annotation>
          
          <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The name of the new LoadBalancer. The name must be unique within your AWS account. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Listeners" type="tns:Listeners">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	A list of LoadBalancerPort, 
                 	<code>InstancePort</code>, 
                 	<code>Protocol</code>, and 
                 	<code>SSLCertificateId</code> items.   	
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerListenersResponse">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="tns:CreateLoadBalancerListenersResult"/>
            <xs:element ref="tns:ResponseMetadata" minOccurs="1"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:element name="CreateLoadBalancerListenersResult">
        <xs:complexType>

            <xs:annotation>
              <xs:documentation><![CDATA[
            		<p>
            		The output for the <a>CreateLoadBalancerListeners</a> action.
            		</p>
                ]]></xs:documentation>
            </xs:annotation>
            
          <xs:sequence>
          </xs:sequence>
        </xs:complexType>
      </xs:element>

      <xs:complexType name="LoadBalancerNames">
        <xs:sequence>
          <xs:element name="member" type="xs:string" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="Instance">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
                The Instance data type.
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="InstanceId" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides an EC2 instance ID.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyTypeDescription">
        <xs:sequence>
            <xs:element name="PolicyTypeName" type="xs:string" minOccurs="0"/>
            <xs:element name="Description" type="xs:string" minOccurs="0"/>
            <xs:element name="PolicyAttributeTypeDescriptions" type="tns:PolicyAttributeTypeDescriptions" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttribute">
        <xs:sequence>
            <xs:element name="AttributeName" type="xs:string" minOccurs="0"/>
            <xs:element name="AttributeValue" type="xs:string" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="Instances">
        <xs:sequence>
          <xs:element name="member" type="tns:Instance" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="HealthCheckInterval">
        <xs:restriction base="xs:integer">
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="PolicyTypeDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:PolicyTypeDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="InstanceStates">
        <xs:sequence>
          <xs:element name="member" type="tns:InstanceState" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="LoadBalancerDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:LoadBalancerDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="SourceSecurityGroup">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
                    This data type is used as a response element in the <a>DescribeLoadBalancers</a> action.
                    For information about Elastic Load Balancing security groups, go to <a href="http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-security-features.html#using-elb-security-groups">Using Security Groups With Elastic Load Balancing</a>
                    in the <i>Elastic Load Balancing Developer Guide</i>. 
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="OwnerAlias" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                          Owner of the source security group. Use this value for the 
                          <code>--source-group-user</code> parameter of the <code>ec2-authorize</code>
                          command in the Amazon EC2 command line tool.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="GroupName" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                          Name of the source security group. Use this value for the 
                          <code>--source-group</code> parameter of the <code>ec2-authorize</code>
                          command in the Amazon EC2 command line tool.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="LoadBalancerDescription">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
               Contains the result of a successful invocation of <a>DescribeLoadBalancers</a>.
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="LoadBalancerName" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the name associated with the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="DNSName" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the external DNS name associated with the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="CanonicalHostedZoneName" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides the name of the Amazon Route 53 hosted zone that is associated
                      with the load balancer. For information on how to associate your load
                      balancer with a hosted zone, go to <a href="http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/using-domain-names-with-elb.html">Using Domain Names With Elastic Load Balancing</a>
                      in the <i>Elastic Load Balancing Developer Guide</i>.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="CanonicalHostedZoneNameID" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides the ID of the Amazon Route 53 hosted zone name that is associated
                      with the load balancer. For information on how to associate or disassociate your load
                      balancer with a hosted zone, go to <a href="http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/using-domain-names-with-elb.html">Using Domain Names With Elastic Load Balancing</a>
                          in the <i>Elastic Load Balancing Developer Guide</i>. 
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="ListenerDescriptions" type="tns:ListenerDescriptions" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      LoadBalancerPort, InstancePort, Protocol, and PolicyNames are returned
                      in a list of tuples in the ListenerDescriptions element.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Policies" type="tns:Policies" minOccurs="0"/>
            <xs:element name="BackendServerDescriptions" type="tns:BackendServerDescriptions" minOccurs="0"/>
            <xs:element name="AvailabilityZones" type="tns:AvailabilityZones" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies a list of Availability Zones.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Instances" type="tns:Instances" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides a list of EC2 instance IDs for the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="HealthCheck" type="tns:HealthCheck" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies information regarding the
                      various health probes conducted on the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="SourceSecurityGroup" type="tns:SourceSecurityGroup" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                          The security group that you can use as part of your inbound rules for 
                          your load balancer's back-end Amazon EC2 application instances.  
                          To disallow traffic from sources other than your load balancer,
                          add a security group rule to your back end instance that specifies this
                          source security group as the inbound source. 
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="CreatedTime" type="xs:dateTime" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides the date and time the LoadBalancer was created.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:PolicyDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttributes">
        <xs:sequence>
          <xs:element name="member" type="tns:PolicyAttribute" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="Cardinality">
        <xs:restriction base="xs:string">
          <xs:enumeration value="ONE"/>
          <xs:enumeration value="ZERO_OR_ONE"/>
          <xs:enumeration value="ZERO_OR_MORE"/>
          <xs:enumeration value="ONE_OR_MORE"/>
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="AvailabilityZones">
        <xs:sequence>
          <xs:element name="member" type="xs:string" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="ListenerDescription">

        <xs:annotation>
          <xs:documentation><![CDATA[
           	<p>
           	The ListenerDescription data type. 
           	</p>
           ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="Listener" type="tns:Listener" minOccurs="0"/>
            <xs:element name="PolicyNames" type="tns:PolicyNames" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	A list of policies enabled for this listener. 
                 	An empty list indicates that no policies are enabled.
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="HealthCheck">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
                The HealthCheck data type.
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="Target" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the instance being checked. The protocol is either TCP or HTTP.
                      The range of valid ports is one (1) through 65535.
                      </p>
                      <note>
                          <p>
                          TCP is the default, specified as a TCP: port pair,
                          for example "TCP:5000". In this case a healthcheck simply
                          attempts to open a TCP connection to the instance on the
                          specified port. Failure to connect within the configured
                          timeout is considered unhealthy.
                          </p>
                          <p>
                          For HTTP, the situation is different. HTTP is specified
                          as a HTTP:port;/;PathToPing; grouping, for example
                          "HTTP:80/weather/us/wa/seattle". In this case, a HTTP GET
                          request is issued to the instance on the given port and path.
                          Any answer other than "200 OK" within the timeout period is
                          considered unhealthy.
                          </p>
                          <p>
                          The total length of the HTTP ping target needs to
                          be 1024 16-bit Unicode characters or less.
                          </p>
                      </note>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Interval" type="tns:HealthCheckInterval">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the approximate interval, in seconds,
                      between health checks of an individual instance.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Timeout" type="tns:HealthCheckTimeout">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the amount of time, in seconds, during which no response
                      means a failed health probe.
                      </p>
                      <note>
                      This value must be less than the <i>Interval</i> value.
                      </note>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="UnhealthyThreshold" type="tns:UnhealthyThreshold">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the number of consecutive health probe failures required
                      before moving the instance to the <i>Unhealthy</i> state.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="HealthyThreshold" type="tns:HealthyThreshold">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the number of consecutive health probe successes required before
                      moving the instance to the <i>Healthy</i> state.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttributeDescription">
        <xs:sequence>
            <xs:element name="AttributeName" type="xs:string" minOccurs="0"/>
            <xs:element name="AttributeValue" type="xs:string" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="LBCookieStickinessPolicy">
        <xs:sequence>
            <xs:element name="PolicyName" type="xs:string" minOccurs="0"/>
            <xs:element name="CookieExpirationPeriod" type="xs:long" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttributeDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:PolicyAttributeDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="Listener">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
                The Listener data type.
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="Protocol" type="xs:string">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the LoadBalancer transport protocol to use for routing
                      - TCP or HTTP.
                      This property cannot be modified for the life of the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="LoadBalancerPort" type="xs:integer">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the external LoadBalancer port number.
                      This property cannot be modified for the life of the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="InstanceProtocol" type="xs:string" minOccurs="0"/>
            <xs:element name="InstancePort" type="tns:InstancePort">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the TCP port on which the instance server is listening.
                      This property cannot be modified for the life of the LoadBalancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="SSLCertificateId" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                 	<p>
                 	The ID of the SSL certificate chain to use. 
                 	For more information on SSL certificates, see  
                 	<a href="http://docs.amazonwebservices.com/IAM/latest/UserGuide/index.html?ManagingCredentials.html">
                 	Managing Keys and Certificates
                 	</a>
                 	in the AWS Identity and Access Management documentation. 
                 	</p>
                 ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="HealthyThreshold">
        <xs:restriction base="xs:integer">
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="PolicyNames">
        <xs:sequence>
          <xs:element name="member" type="xs:string" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="BackendServerDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:BackendServerDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttributeTypeDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:PolicyAttributeTypeDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="UnhealthyThreshold">
        <xs:restriction base="xs:integer">
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="LBCookieStickinessPolicies">
        <xs:sequence>
          <xs:element name="member" type="tns:LBCookieStickinessPolicy" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="Listeners">
        <xs:sequence>
          <xs:element name="member" type="tns:Listener" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="AppCookieStickinessPolicies">
        <xs:sequence>
          <xs:element name="member" type="tns:AppCookieStickinessPolicy" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyDescription">
        <xs:sequence>
            <xs:element name="PolicyName" type="xs:string" minOccurs="0"/>
            <xs:element name="PolicyTypeName" type="xs:string" minOccurs="0"/>
            <xs:element name="PolicyAttributeDescriptions" type="tns:PolicyAttributeDescriptions" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyTypeNames">
        <xs:sequence>
          <xs:element name="member" type="xs:string" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="Policies">
        <xs:sequence>
            <xs:element name="AppCookieStickinessPolicies" type="tns:AppCookieStickinessPolicies" minOccurs="0"/>
            <xs:element name="LBCookieStickinessPolicies" type="tns:LBCookieStickinessPolicies" minOccurs="0"/>
            <xs:element name="OtherPolicies" type="tns:PolicyNames" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="PolicyAttributeTypeDescription">
        <xs:sequence>
            <xs:element name="AttributeName" type="xs:string" minOccurs="0"/>
            <xs:element name="AttributeType" type="xs:string" minOccurs="0"/>
            <xs:element name="Description" type="xs:string" minOccurs="0"/>
            <xs:element name="DefaultValue" type="xs:string" minOccurs="0"/>
            <xs:element name="Cardinality" type="tns:Cardinality" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="InstancePort">
        <xs:restriction base="xs:integer">
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="Ports">
        <xs:sequence>
          <xs:element name="member" type="xs:integer" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="BackendServerDescription">
        <xs:sequence>
            <xs:element name="InstancePort" type="tns:InstancePort" minOccurs="0"/>
            <xs:element name="PolicyNames" type="tns:PolicyNames" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="ListenerDescriptions">
        <xs:sequence>
          <xs:element name="member" type="tns:ListenerDescription" maxOccurs="unbounded"/>
        </xs:sequence>
      </xs:complexType>

      <xs:complexType name="InstanceState">

        <xs:annotation>
          <xs:documentation><![CDATA[
                <p>
                The InstanceState data type.
                </p>
            ]]></xs:documentation>
        </xs:annotation>
        
        <xs:sequence>
            <xs:element name="InstanceId" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides an EC2 instance ID.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="State" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Specifies the current status of the instance.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="ReasonCode" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                      Provides information about the cause of <i>OutOfService</i> instances.
                      Specifically, it indicates whether the cause is Elastic Load Balancing
                      or the instance behind the Load Balancer.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
            <xs:element name="Description" type="xs:string" minOccurs="0">

              <xs:annotation>
                <xs:documentation><![CDATA[
                      <p>
                          Provides a description of the instance.
                      </p>
                  ]]></xs:documentation>
              </xs:annotation>
              
            </xs:element>
        </xs:sequence>
      </xs:complexType>

      <xs:simpleType name="HealthCheckTimeout">
        <xs:restriction base="xs:integer">
        </xs:restriction>
      </xs:simpleType>

      <xs:complexType name="AppCookieStickinessPolicy">
        <xs:sequence>
            <xs:element name="PolicyName" type="xs:string" minOccurs="0"/>
            <xs:element name="CookieName" type="xs:string" minOccurs="0"/>
        </xs:sequence>
      </xs:complexType>

    </xs:schema>

  </wsdl:types>

  <wsdl:message name="ConfigureHealthCheckRequestMsg">
    <wsdl:part element="tns:ConfigureHealthCheck" name="body"/>
  </wsdl:message>

  <wsdl:message name="ConfigureHealthCheckResponseMsg">
    <wsdl:part element="tns:ConfigureHealthCheckResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerPoliciesForBackendServerRequestMsg">
    <wsdl:part element="tns:SetLoadBalancerPoliciesForBackendServer" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerPoliciesForBackendServerResponseMsg">
    <wsdl:part element="tns:SetLoadBalancerPoliciesForBackendServerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerListenerSSLCertificateRequestMsg">
    <wsdl:part element="tns:SetLoadBalancerListenerSSLCertificate" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerListenerSSLCertificateResponseMsg">
    <wsdl:part element="tns:SetLoadBalancerListenerSSLCertificateResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="RegisterInstancesWithLoadBalancerRequestMsg">
    <wsdl:part element="tns:RegisterInstancesWithLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="RegisterInstancesWithLoadBalancerResponseMsg">
    <wsdl:part element="tns:RegisterInstancesWithLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerPoliciesOfListenerRequestMsg">
    <wsdl:part element="tns:SetLoadBalancerPoliciesOfListener" name="body"/>
  </wsdl:message>

  <wsdl:message name="SetLoadBalancerPoliciesOfListenerResponseMsg">
    <wsdl:part element="tns:SetLoadBalancerPoliciesOfListenerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerListenersRequestMsg">
    <wsdl:part element="tns:DeleteLoadBalancerListeners" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerListenersResponseMsg">
    <wsdl:part element="tns:DeleteLoadBalancerListenersResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLBCookieStickinessPolicyRequestMsg">
    <wsdl:part element="tns:CreateLBCookieStickinessPolicy" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLBCookieStickinessPolicyResponseMsg">
    <wsdl:part element="tns:CreateLBCookieStickinessPolicyResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancerPoliciesRequestMsg">
    <wsdl:part element="tns:DescribeLoadBalancerPolicies" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancerPoliciesResponseMsg">
    <wsdl:part element="tns:DescribeLoadBalancerPoliciesResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancerPolicyTypesRequestMsg">
    <wsdl:part element="tns:DescribeLoadBalancerPolicyTypes" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancerPolicyTypesResponseMsg">
    <wsdl:part element="tns:DescribeLoadBalancerPolicyTypesResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DisableAvailabilityZonesForLoadBalancerRequestMsg">
    <wsdl:part element="tns:DisableAvailabilityZonesForLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="DisableAvailabilityZonesForLoadBalancerResponseMsg">
    <wsdl:part element="tns:DisableAvailabilityZonesForLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerRequestMsg">
    <wsdl:part element="tns:CreateLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerResponseMsg">
    <wsdl:part element="tns:CreateLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="EnableAvailabilityZonesForLoadBalancerRequestMsg">
    <wsdl:part element="tns:EnableAvailabilityZonesForLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="EnableAvailabilityZonesForLoadBalancerResponseMsg">
    <wsdl:part element="tns:EnableAvailabilityZonesForLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerPolicyRequestMsg">
    <wsdl:part element="tns:CreateLoadBalancerPolicy" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerPolicyResponseMsg">
    <wsdl:part element="tns:CreateLoadBalancerPolicyResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeregisterInstancesFromLoadBalancerRequestMsg">
    <wsdl:part element="tns:DeregisterInstancesFromLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeregisterInstancesFromLoadBalancerResponseMsg">
    <wsdl:part element="tns:DeregisterInstancesFromLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateAppCookieStickinessPolicyRequestMsg">
    <wsdl:part element="tns:CreateAppCookieStickinessPolicy" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateAppCookieStickinessPolicyResponseMsg">
    <wsdl:part element="tns:CreateAppCookieStickinessPolicyResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerRequestMsg">
    <wsdl:part element="tns:DeleteLoadBalancer" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerResponseMsg">
    <wsdl:part element="tns:DeleteLoadBalancerResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerPolicyRequestMsg">
    <wsdl:part element="tns:DeleteLoadBalancerPolicy" name="body"/>
  </wsdl:message>

  <wsdl:message name="DeleteLoadBalancerPolicyResponseMsg">
    <wsdl:part element="tns:DeleteLoadBalancerPolicyResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeInstanceHealthRequestMsg">
    <wsdl:part element="tns:DescribeInstanceHealth" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeInstanceHealthResponseMsg">
    <wsdl:part element="tns:DescribeInstanceHealthResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancersRequestMsg">
    <wsdl:part element="tns:DescribeLoadBalancers" name="body"/>
  </wsdl:message>

  <wsdl:message name="DescribeLoadBalancersResponseMsg">
    <wsdl:part element="tns:DescribeLoadBalancersResponse" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerListenersRequestMsg">
    <wsdl:part element="tns:CreateLoadBalancerListeners" name="body"/>
  </wsdl:message>

  <wsdl:message name="CreateLoadBalancerListenersResponseMsg">
    <wsdl:part element="tns:CreateLoadBalancerListenersResponse" name="body"/>
  </wsdl:message>

  <wsdl:portType name="ElasticLoadBalancingPortType">

    <wsdl:operation name="ConfigureHealthCheck">
      <wsdl:documentation><![CDATA[
        <p>
        Enables the client to define an application
        healthcheck for the instances.
        </p>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:ConfigureHealthCheckRequestMsg" wsa:Action="urn:ConfigureHealthCheck"/>
      <wsdl:output message="tns:ConfigureHealthCheckResponseMsg" wsa:Action="urn:ConfigureHealthCheck:Response"/>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerPoliciesForBackendServer">
      <wsdl:input message="tns:SetLoadBalancerPoliciesForBackendServerRequestMsg" wsa:Action="urn:SetLoadBalancerPoliciesForBackendServer"/>
      <wsdl:output message="tns:SetLoadBalancerPoliciesForBackendServerResponseMsg" wsa:Action="urn:SetLoadBalancerPoliciesForBackendServer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerListenerSSLCertificate">
      <wsdl:documentation><![CDATA[
   	<p>
   	Sets the certificate that terminates the specified listener's SSL connections. 
   	The specified certificate replaces any prior certificate that was used on the same LoadBalancer and port. 
   	</p>
   ]]></wsdl:documentation>
      <wsdl:input message="tns:SetLoadBalancerListenerSSLCertificateRequestMsg" wsa:Action="urn:SetLoadBalancerListenerSSLCertificate"/>
      <wsdl:output message="tns:SetLoadBalancerListenerSSLCertificateResponseMsg" wsa:Action="urn:SetLoadBalancerListenerSSLCertificate:Response"/>
    </wsdl:operation>

    <wsdl:operation name="RegisterInstancesWithLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Adds new instances to the LoadBalancer.
        </p>
        <p>
        Once the instance is registered, it starts receiving traffic
        and requests from the LoadBalancer. Any instance that is not
        in any of the Availability Zones registered for the LoadBalancer
        will be moved to the <i>OutOfService</i> state. It will move to the
        <i>InService</i> state when the Availability Zone is added to the LoadBalancer.
        </p>
        <note>
        In order for this call to be successful, the client
        must have created the LoadBalancer.
        The client must provide the same account credentials
        as those that were used to create the LoadBalancer.
        </note>
        <note>
        Completion of this API does not guarantee that operation has completed.
        Rather, it means that the request has been registered and the
        changes will happen shortly.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:RegisterInstancesWithLoadBalancerRequestMsg" wsa:Action="urn:RegisterInstancesWithLoadBalancer"/>
      <wsdl:output message="tns:RegisterInstancesWithLoadBalancerResponseMsg" wsa:Action="urn:RegisterInstancesWithLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerPoliciesOfListener">
      <wsdl:documentation><![CDATA[
        <p>
        Associates, updates, or disables a policy with a listener on the load balancer. 
        Currently only zero (0) or one (1) policy can be associated with a listener. 
        </p>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:SetLoadBalancerPoliciesOfListenerRequestMsg" wsa:Action="urn:SetLoadBalancerPoliciesOfListener"/>
      <wsdl:output message="tns:SetLoadBalancerPoliciesOfListenerResponseMsg" wsa:Action="urn:SetLoadBalancerPoliciesOfListener:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancerListeners">
      <wsdl:documentation><![CDATA[
   	<p>
   	Deletes listeners from the LoadBalancer for the specified port.
   	</p>
   ]]></wsdl:documentation>
      <wsdl:input message="tns:DeleteLoadBalancerListenersRequestMsg" wsa:Action="urn:DeleteLoadBalancerListeners"/>
      <wsdl:output message="tns:DeleteLoadBalancerListenersResponseMsg" wsa:Action="urn:DeleteLoadBalancerListeners:Response"/>
    </wsdl:operation>

    <wsdl:operation name="CreateLBCookieStickinessPolicy">
      <wsdl:documentation><![CDATA[
        <p>
        Generates a stickiness policy with sticky session lifetimes controlled by the 
        lifetime of the browser (user-agent) or a specified expiration period. This 
        policy can be associated only with HTTP/HTTPS listeners.
        </p>
        <p>
        When a load balancer implements this policy, the load balancer uses a special
        cookie to track the backend server instance for each request. When the load balancer
        receives a request, it first checks to see if this cookie is present in the request. 
        If so, the load balancer sends the request to the application server specified in the
        cookie. If not, the load balancer sends the request to a server that is chosen based on
        the existing load balancing algorithm.
        </p>
        <p>
        A cookie is inserted into the response for binding subsequent requests from the same user to
        that server. The validity of the cookie is based on the cookie expiration time, which is 
        specified in the policy configuration. 
        </p>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:CreateLBCookieStickinessPolicyRequestMsg" wsa:Action="urn:CreateLBCookieStickinessPolicy"/>
      <wsdl:output message="tns:CreateLBCookieStickinessPolicyResponseMsg" wsa:Action="urn:CreateLBCookieStickinessPolicy:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancerPolicies">
      <wsdl:input message="tns:DescribeLoadBalancerPoliciesRequestMsg" wsa:Action="urn:DescribeLoadBalancerPolicies"/>
      <wsdl:output message="tns:DescribeLoadBalancerPoliciesResponseMsg" wsa:Action="urn:DescribeLoadBalancerPolicies:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancerPolicyTypes">
      <wsdl:input message="tns:DescribeLoadBalancerPolicyTypesRequestMsg" wsa:Action="urn:DescribeLoadBalancerPolicyTypes"/>
      <wsdl:output message="tns:DescribeLoadBalancerPolicyTypesResponseMsg" wsa:Action="urn:DescribeLoadBalancerPolicyTypes:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DisableAvailabilityZonesForLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Removes the specified EC2 Availability Zones from
        the set of configured Availability Zones for the LoadBalancer.
        </p>
        <p>
        There must be at least one Availability Zone registered
        with a LoadBalancer at all times. A client cannot remove all
        the Availability Zones from a LoadBalancer.
        Once an Availability Zone is removed, all the instances
        registered with the LoadBalancer that are in the removed
        Availability Zone go into the OutOfService state. Upon Availability
        Zone removal, the LoadBalancer attempts to equally balance
        the traffic among its remaining usable Availability Zones.
        Trying to remove an Availability Zone that was not associated with
        the LoadBalancer does nothing.
        </p>
        <note>
        In order for this call to be successful, the client
        must have created the LoadBalancer.
        The client must provide the same account credentials
        as those that were used to create the LoadBalancer.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:DisableAvailabilityZonesForLoadBalancerRequestMsg" wsa:Action="urn:DisableAvailabilityZonesForLoadBalancer"/>
      <wsdl:output message="tns:DisableAvailabilityZonesForLoadBalancerResponseMsg" wsa:Action="urn:DisableAvailabilityZonesForLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Creates a new LoadBalancer.
        </p>
        <p>
        Once the call has completed successfully, a new LoadBalancer
        is created; however, it will not be usable until at least
        one instance has been registered.
        When the LoadBalancer creation is completed,
        the client can check whether or not it is usable by
        using the DescribeInstanceHealth API.
        The LoadBalancer is usable as soon as any registered instance
        is <i>InService</i>.
        </p>
        <note>
        Currently, the client's quota of LoadBalancers is
        limited to five per Region.
        </note>
        <note>
            <p>
            Load balancer DNS names vary depending on the Region
            they're created in. For load balancers created in the United States,
            the DNS name ends with:
            </p>
            <ul>
                <li>
                <i>us-east-1.elb.amazonaws.com</i> (for the US Standard Region)
                </li>
                <li>
                <i>us-west-1.elb.amazonaws.com</i> (for the Northern California Region)
                </li>
            </ul>
            <p>
            For load balancers created in the EU (Ireland) Region,
            the DNS name ends with:
            </p>
            <ul>
                <li>
                <i>eu-west-1.elb.amazonaws.com</i>
                </li>
            </ul>
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:CreateLoadBalancerRequestMsg" wsa:Action="urn:CreateLoadBalancer"/>
      <wsdl:output message="tns:CreateLoadBalancerResponseMsg" wsa:Action="urn:CreateLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="EnableAvailabilityZonesForLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Adds one or more EC2 Availability Zones to the LoadBalancer.
        </p>
        <p>
        The LoadBalancer evenly distributes requests across all
        its registered Availability Zones that contain instances.
        As a result, the client must ensure that its LoadBalancer is
        appropriately scaled for each registered Availability Zone.
        </p>
        <note>
        The new EC2 Availability Zones to be added must be in the same
        EC2 Region as the Availability Zones for which the
        LoadBalancer was created.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:EnableAvailabilityZonesForLoadBalancerRequestMsg" wsa:Action="urn:EnableAvailabilityZonesForLoadBalancer"/>
      <wsdl:output message="tns:EnableAvailabilityZonesForLoadBalancerResponseMsg" wsa:Action="urn:EnableAvailabilityZonesForLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancerPolicy">
      <wsdl:input message="tns:CreateLoadBalancerPolicyRequestMsg" wsa:Action="urn:CreateLoadBalancerPolicy"/>
      <wsdl:output message="tns:CreateLoadBalancerPolicyResponseMsg" wsa:Action="urn:CreateLoadBalancerPolicy:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DeregisterInstancesFromLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Deregisters instances from the LoadBalancer.
        Once the instance is deregistered,
        it will stop receiving traffic from the LoadBalancer.
        </p>
        <p>
        In order to successfully call this API,
        the same account credentials as those
        used to create the LoadBalancer must be provided.
        </p>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:DeregisterInstancesFromLoadBalancerRequestMsg" wsa:Action="urn:DeregisterInstancesFromLoadBalancer"/>
      <wsdl:output message="tns:DeregisterInstancesFromLoadBalancerResponseMsg" wsa:Action="urn:DeregisterInstancesFromLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="CreateAppCookieStickinessPolicy">
      <wsdl:documentation><![CDATA[
        <p>
        Generates a stickiness policy with sticky session lifetimes that follow 
        that of an application-generated cookie. This policy can be associated
        only with HTTP/HTTPS listeners.
        </p>
        <p>
        This policy is similar to the policy created by CreateLBCookieStickinessPolicy, 
        except that the lifetime of the special Elastic Load Balancing cookie follows the
        lifetime of the application-generated cookie specified in the policy configuration. 
        The load balancer only inserts a new stickiness cookie when the application response
        includes a new application cookie. 
        </p>
        <p>
        If the application cookie is explicitly removed or expires, the session stops being
        sticky until a new application cookie is issued. 
        </p>
        <note>
            An application client must receive and send two cookies: the application-generated 
            cookie and the special Elastic Load Balancing cookie named <code>AWSELB</code>. 
            This is the default behavior for many common web browsers.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:CreateAppCookieStickinessPolicyRequestMsg" wsa:Action="urn:CreateAppCookieStickinessPolicy"/>
      <wsdl:output message="tns:CreateAppCookieStickinessPolicyResponseMsg" wsa:Action="urn:CreateAppCookieStickinessPolicy:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancer">
      <wsdl:documentation><![CDATA[
        <p>
        Deletes the specified LoadBalancer.
        </p>
        <p>
        If attempting to recreate the LoadBalancer,
        the client must reconfigure all the settings.
        The DNS name associated with a deleted LoadBalancer
        will no longer be usable.
        Once deleted, the name and associated DNS record of the
        LoadBalancer no longer exist and traffic sent to any of its
        IP addresses will no longer be delivered to client instances.
        The client will not receive the same DNS name even if a
        new LoadBalancer with same LoadBalancerName is created.
        </p>
        <p>
        To successfully call this API, the client must provide the same
        account credentials as were used to create the LoadBalancer.
        </p>
        <note>
        By design, if the LoadBalancer does not exist or has already been deleted,
        DeleteLoadBalancer still succeeds.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:DeleteLoadBalancerRequestMsg" wsa:Action="urn:DeleteLoadBalancer"/>
      <wsdl:output message="tns:DeleteLoadBalancerResponseMsg" wsa:Action="urn:DeleteLoadBalancer:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancerPolicy">
      <wsdl:documentation><![CDATA[
   	<p>
   	Deletes a policy from the LoadBalancer. 
   	The specified policy must not be enabled for any listeners.
   	</p>
   ]]></wsdl:documentation>
      <wsdl:input message="tns:DeleteLoadBalancerPolicyRequestMsg" wsa:Action="urn:DeleteLoadBalancerPolicy"/>
      <wsdl:output message="tns:DeleteLoadBalancerPolicyResponseMsg" wsa:Action="urn:DeleteLoadBalancerPolicy:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DescribeInstanceHealth">
      <wsdl:documentation><![CDATA[
        <p>
        Returns the current state of the instances of the specified LoadBalancer.
        If no instances are specified, the state of all the instances for the
        LoadBalancer is returned.
        </p>
        <note>
        The client must have created the specified input
        LoadBalancer in order to retrieve this information;
        the client must provide the same account credentials
        as those that were used to create the LoadBalancer.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:DescribeInstanceHealthRequestMsg" wsa:Action="urn:DescribeInstanceHealth"/>
      <wsdl:output message="tns:DescribeInstanceHealthResponseMsg" wsa:Action="urn:DescribeInstanceHealth:Response"/>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancers">
      <wsdl:documentation><![CDATA[
        <p>
        Returns detailed configuration information
        for the specified LoadBalancers. If no LoadBalancers are specified,
        the operation returns configuration information
        for all LoadBalancers created by the caller.
        </p>
        <note>
        The client must have created the specified input
        LoadBalancers in order to retrieve this information;
        the client must provide the same account credentials
        as those that were used to create the LoadBalancer.
        </note>
    ]]></wsdl:documentation>
      <wsdl:input message="tns:DescribeLoadBalancersRequestMsg" wsa:Action="urn:DescribeLoadBalancers"/>
      <wsdl:output message="tns:DescribeLoadBalancersResponseMsg" wsa:Action="urn:DescribeLoadBalancers:Response"/>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancerListeners">
      <wsdl:documentation><![CDATA[
   	<p>
   	Creates one or more listeners on a LoadBalancer for the specified port. 
   	If a listener with the given port does not already exist, it will be created; 
   	otherwise, the properties of the new listener must match the properties 
   	of the existing listener. 
   	</p>
   ]]></wsdl:documentation>
      <wsdl:input message="tns:CreateLoadBalancerListenersRequestMsg" wsa:Action="urn:CreateLoadBalancerListeners"/>
      <wsdl:output message="tns:CreateLoadBalancerListenersResponseMsg" wsa:Action="urn:CreateLoadBalancerListeners:Response"/>
    </wsdl:operation>

  </wsdl:portType>

  <wsdl:binding name="ElasticLoadBalancingBinding" type="tns:ElasticLoadBalancingPortType">

    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>

    <wsdl:operation name="ConfigureHealthCheck">
      <soap:operation soapAction="ConfigureHealthCheck"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerPoliciesForBackendServer">
      <soap:operation soapAction="SetLoadBalancerPoliciesForBackendServer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerListenerSSLCertificate">
      <soap:operation soapAction="SetLoadBalancerListenerSSLCertificate"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="RegisterInstancesWithLoadBalancer">
      <soap:operation soapAction="RegisterInstancesWithLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="SetLoadBalancerPoliciesOfListener">
      <soap:operation soapAction="SetLoadBalancerPoliciesOfListener"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancerListeners">
      <soap:operation soapAction="DeleteLoadBalancerListeners"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="CreateLBCookieStickinessPolicy">
      <soap:operation soapAction="CreateLBCookieStickinessPolicy"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancerPolicies">
      <soap:operation soapAction="DescribeLoadBalancerPolicies"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancerPolicyTypes">
      <soap:operation soapAction="DescribeLoadBalancerPolicyTypes"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DisableAvailabilityZonesForLoadBalancer">
      <soap:operation soapAction="DisableAvailabilityZonesForLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancer">
      <soap:operation soapAction="CreateLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="EnableAvailabilityZonesForLoadBalancer">
      <soap:operation soapAction="EnableAvailabilityZonesForLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancerPolicy">
      <soap:operation soapAction="CreateLoadBalancerPolicy"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DeregisterInstancesFromLoadBalancer">
      <soap:operation soapAction="DeregisterInstancesFromLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="CreateAppCookieStickinessPolicy">
      <soap:operation soapAction="CreateAppCookieStickinessPolicy"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancer">
      <soap:operation soapAction="DeleteLoadBalancer"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DeleteLoadBalancerPolicy">
      <soap:operation soapAction="DeleteLoadBalancerPolicy"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DescribeInstanceHealth">
      <soap:operation soapAction="DescribeInstanceHealth"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="DescribeLoadBalancers">
      <soap:operation soapAction="DescribeLoadBalancers"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

    <wsdl:operation name="CreateLoadBalancerListeners">
      <soap:operation soapAction="CreateLoadBalancerListeners"/>
      <wsdl:input><soap:body use="literal"/></wsdl:input>
      <wsdl:output><soap:body use="literal"/></wsdl:output>
    </wsdl:operation>

  </wsdl:binding>

  <wsdl:service name="ElasticLoadBalancing">
    <wsdl:documentation><![CDATA[
    	<fullname>Elastic Load Balancing</fullname>
        <p>
        Elastic Load Balancing is a cost-effective and easy
        to use web service to help you improve availability and
        scalability of your application. It makes it easy for
        you to distribute application loads between two or more
        EC2 instances. Elastic Load Balancing enables availability
        through redundancy and supports traffic growth of your application.
        </p>
    ]]></wsdl:documentation>
    <wsdl:port name="ElasticLoadBalancingPort" binding="tns:ElasticLoadBalancingBinding">
      <soap:address location="https://elasticloadbalancing.amazonaws.com/"/>
    </wsdl:port>
  </wsdl:service>

</wsdl:definitions>