<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:wsa="http://www.w3.org/2005/08/addressing">
    <soapenv:Header xmlns:fabrikam="http://example.com/fabrikam" xmlns:axis2="http://ws.apache.org/namespaces/axis2">
        <wsa:MessageID axis2:AttrExt="123456789" soapenv:mustUnderstand="0">
            uuid:920C5190-0B8F-11D9-8CED-F22EDEEBF7E5</wsa:MessageID>
        <wsa:To axis2:AttrExt="123456789" soapenv:mustUnderstand="0">http://localhost:8081/axis/services/BankPort</wsa:To>
        <axis2:ParamOne wsa:IsReferenceParameter='true'>0123456789</axis2:ParamOne>
        <axis2:ParamTwo wsa:IsReferenceParameter='true'>ABCDEFG</axis2:ParamTwo>
        <axis2:ParamThree wsa:IsReferenceParameter='true'>abcdefg</axis2:ParamThree>
        <axis2:ParamFour wsa:IsReferenceParameter='1'>xyz</axis2:ParamFour>
        <wsa:Action axis2:AttrExt="123456789">http://ws.apache.org/tests/action</wsa:Action>
        <wsa:ReplyTo axis2:AttrExt="123456789">
            <wsa:Address>http://example.com/fabrikam/acct</wsa:Address>
            <wsa:ReferenceParameters>
                <fabrikam:CustomerKey>123456789</fabrikam:CustomerKey>
                <fabrikam:ShoppingCart>ABCDEFG</fabrikam:ShoppingCart>
            </wsa:ReferenceParameters>
            <wsa:Metadata>
                <axis2:MetaExt axis2:AttrExt="123456789">123456789</axis2:MetaExt>
            </wsa:Metadata>
            <axis2:EPRExt axis2:AttrExt="123456789">123456789</axis2:EPRExt>
        </wsa:ReplyTo>
    </soapenv:Header>
    <soapenv:Body>
        <ns1:getBalance soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
                xmlns:ns1="http://localhost:8081/axis/services/BankPort">
            <accountNo href="#id0"/>
        </ns1:getBalance>
        <multiRef id="id0" soapenc:root="0"
                soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
                xsi:type="xsd:int" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/">
            1001</multiRef>
    </soapenv:Body>
</soapenv:Envelope>