import SOAP-WSDL 2.00_06 from CPAN

git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_06 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_06.tar.gz
import SOAP-WSDL 2.00_05 from CPAN
2009-12-12 19:47:44 -08:00 · 2009-12-12 19:47:43 -08:00 · 2009-12-12 19:47:43 -08:00 · 2009-12-12 19:47:42 -08:00 · 2009-12-12 19:47:41 -08:00 · 2009-12-12 19:47:41 -08:00
160 changed files with 13388 additions and 1974 deletions
--- a/Build.PL
+++ b/Build.PL
@@ -1,7 +1,41 @@
 use Module::Build;
-   Module::Build->new(
-   		dist_abstract => 'WSDL support for SOAP::Lite',
-       module_name => 'SOAP::WSDL',
-       license => 'artistic',
-       requires => { 'SOAP::Lite' => 0.55, 'XML::XPath' => 0 }
-   )->create_build_script;
+Module::Build->new(
+	dist_abstract => 'SOAP with WSDL support',
+	dist_name => 'SOAP-WSDL',
+	dist_version => '2.00_06',
+	module_name   => 'SOAP::WSDL',
+	license       => 'artistic',
+	requires      => {
+	    'Class::Std' => q/v0.0.8/,
+	    'Class::Std::Storable' => 0,
+            'SOAP::Lite' => 0,
+            'List::Util' => 0,
+            'File::Basename' => 0,
+            'File::Path' => 0,
+            'XML::XPath' => 0,
+            'XML::LibXML' => 0,
+            'XML::SAX::Base' => 0,
+            'XML::SAX::ParserFactory' => 0,
+		'XML::Parser::Expat' => 0,
+	},
+	buildrequires => {	
+	    'Benchmark' => 0, 
+	    'Cwd' => 0,    
+	    'Test::More' => 0,
+        'SOAP::Lite' => 0,
+	    'Class::Std' => 0.0.8,
+	    'Class::Std::Storable' => 0,        
+        'List::Util' => 0,
+        'File::Basename' => 0,
+        'File::Path' => 0,
+		'XML::XPath' => 0,
+		'XML::Simple' => 0,
+		'XML::LibXML' => 0,
+		'XML::Parser::Expat' => 0,
+		'XML::SAX::Base' => 0,
+		'XML::SAX::ParserFactory' => 0,
+		'Pod::Simple::Text' => 0,
+		'XML::SAX::ParserFactory' => 0,
+	},
+	recursive_test_files => 1,
+)->create_build_script;
--- a/147
+++ b/147
@@ -1,146 +1 @@
-2007/05/28 private methods made private and pod update
-  - added pod tests
-  - made encodeComplexType and method generators private
-  - updated pod
-  - fixed test scripts to work again from within/without t/
-  - moved development repository to 
-  https://svn.sourceforge.net/svnroot/soap-wsdl/ (finally !)
-
-2007/05/21 updated base version to customized version from Giovanni S Fois
-  - merged in doc changes, so that they don't refer to "customized version" 
-  - changed build process to Build.PL 
-  - changed repository layout to support new build process
-
-2006/11/06 only in the customized version
-  Added the support for default values in the wsdl file
-
-2006/11/04 only in the customized version
-  Changed the calling interface. Now it's driven by the by the service 
-  and port names.
-
-2006/11/03 only in the customized version
-  Corrected the Check for the correct number of elements in complex types
-
-  If a complex type is marked optional in a WSDL file, but sub-parts are marked as 
-  required, SOAP::WSDL used to die if the complex type was found in the data.
-  Now, if a complex type has not data associated and is not strictly required, it
-  will not be encoded.
-
-A quick-and-dirty workaround is to turn off the check with 
-
- $soap->wsdl_checkoccurs(0);
-
-2006/11/02 only in the customized version 
-  - small changes for .Net compatibility when encoding complex types
-  - added some test cases to the test suite try perl t/3_varous.t for more details
-
-
-2006/10/28 only in the customized version 
-  - added a small support for the complexType restrictions of Arrays
-
-2006/10/02 only in the customized version 
-           (Thanks to Dan Horne for having spotted so many bugs in a row)
- the xml prefix was used as the default wsdl namespace when looking for the complextype restrictions
- the module crashed when the operation had no part declaration
- the port name stated in the service definition was used as the portType
- the test suited failed when the module was unzipped in a t.* named directory
-
-
-
-2006/09/15 only in the customized version 
-           (Thanks to Terje Kristensen for his support and twisted wsdl files :)
- cleaned up the code for readability
- cleaned up the code for "use warnings" and "use strict"
- added support for wsdl files with multiple schema declarations
- added supporto for some restriction on complexTypes
-
-
- 
-
-2006/07/10 only in the customized version
-   - added the support for SOAP::header calls
-
-2006/06/10 only in the customized version
-
-  - removed the overload based on the type of the call's parameters
-
-  - added an overloading support based on the unique name of the input message of the call. The input message must be provided by the calling script (sorry, the module has no mean to find this).
-
-  - added a light support to the sympletypes.
-
-  - added a light support to the imported namespaces in the types section.
-
-  - added the support for the multiple SOAP bindings. The correct binding must be provided by the calling script (sorry, the module has no mean to find this).
-
-  - the method will use his own soapAction if defined
-
-  - the method will use his own namespace if defined
-
-  - some other code cleaning
-
-2006/04/23 only in the customized version
-
-  - corrected a bug related to the presence of the same method name on multiple 
-    webservices
-
-  - added an overloading support based on the type of the call's parameters
-
-  - multiple extensions support added: a complextype can be an extension of a complextype which is an extension and so on
-
-
-
-Revision 1.7  2004/07/27 13:00:03  lsc
- added missing test file
-
-Revision 1.18  2004/07/16 07:43:05  lsc
-fixed test scripts for windows
-
-Revision 1.17  2004/07/05 08:19:49  lsc
- added wsdl_checkoccurs
-
-Revision 1.16  2004/07/04 09:01:14  lsc
- change <definitions> element lookup from find('/definitions') and find('wsdl:definitions') to find('/*[1]') to process arbitrary default (wsdl) namespaces correctly
- fixed test output in test 06
-
-Revision 1.15  2004/07/02 12:28:31  lsc
- documentation update
- cosmetics
-
-Revision 1.14  2004/07/02 10:53:36  lsc
- API change:
-    - call now behaves (almost)  like SOAP::Lite::call
-    - call() takes a list (hash) as second argument
-    - call does no longer support the "dispatch" option
-    - dispatching calls can be suppressed by passing
-         "no_dispatch => 1" to new()
-    - dispatching calls can be suppressed by calling
-           $soap->no_dispatch(1);
-       and re-enabled by calling
-           $soap->no_dispatch(0);
- Updated test skripts to reflect API change.
-
-Revision 1.13  2004/06/30 12:08:40  lsc
- added IServiceInstance (ecmed) to acceptance tests
- refined documentation
-
-Revision 1.12  2004/06/26 14:13:29  lsc
- refined file caching
- added descriptive output to test scripts
-
-Revision 1.11  2004/06/26 07:55:40  lsc
- fixed "freeze" caching bug
- improved test scripts to test file system caching (and show the difference)
-
-Revision 1.10  2004/06/26 06:30:33  lsc
- added filesystem caching using Cache::FileCache
-
-Revision 1.9  2004/06/24 12:27:23  lsc
-Cleanup
-
-Revision 1.8  2004/06/11 19:49:15  lsc
- moved .t files to more self-describing names
- changed WSDL.pm to accept AXIS wsdl files
- implemented XPath query result caching on all absolute queries
-
-Revision 1.7  2004/06/07 13:01:16  lsc
-added changelog to pod
+See perldoc SOAP::WSDL
--- a/33
+++ b/33
@@ -1,7 +1,7 @@
 Development of SOAP::WSDL takes place on sourceforge.net.

 There's a svn repository available at 
-https://svn.sourceforge.net/svnroot/soap-wsdl
+https://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl

 Engagement in the further development of this module is highly encouraged - 
 many people have already contributed, and many more probably will.
@@ -14,11 +14,36 @@ you as co-author.
 The (my) current roadmap for SOAP::WSDL is:

 1.2*: Bugfixes and support for more XSD variants
-
 1.3: Bindings support

-2.*: WSDL -> Perl Class factory with offline WSDL processing
+Development of the 1.* tree has stopped - I won't get past 1.2x anymore...

-May 2007,
+2.*: WSDL -> Perl Class factory with offline WSDL processing
+
+2.01
+- WSDL support for the most common type definitions
+- Online-facility (SOAP::WSDL) using WSDL object tree directly
+- usable code generator
+- full namespace support when processing WSDL
+- high performance when parsing WSDL messages - get nearly as fast as 
+  XML::Simple...
+
+2.02
+- Support for Apache-SOAP datatypes
+- support for embedded atomic simpleType/complexType definitions
+- Caching of WSDL object tree + generated code (when using SOAP::WSDL).
+- Online-facility (SOAP::WSDL) using code generator via cache directory
+
+Somewhere on the TODO list (in no particular order):
+
+- validation
+- typemaps for use with the type="tns:MyComplexType" XML attribute
+- external entities support when parsing WSDL
+- support all these XML Schema variants 
+- support creating XML Schmema definitions via SOAP::WSDL::XSD::* ('minimal conformant')
+- support other Schema definition languages than XML::Schema (maybe RelaxNG?)
+- factor out SOAP::WSDL::XSD into it's own namespace (maybe just XSD ?)
+
+July 2007,

 Martin Kutter
--- a/7
+++ b/7
@@ -0,0 +1,7 @@
+SOAP::WSDL is dual licensed under the same terms as
+Perl itself.
+
+This means at your choice, either the Perl Artistic License, or
+the GNU GPL version 1 or higher.
+
+
--- a/158
+++ b/158
@@ -2,14 +2,154 @@ Build.PL
 CHANGES
 HACKING
 lib/SOAP/WSDL.pm
-MANIFEST			This list of files
+lib/SOAP/WSDL/Base.pm
+lib/SOAP/WSDL/Binding.pm
+lib/SOAP/WSDL/Client.pm
+lib/SOAP/WSDL/Client/Base.pm
+lib/SOAP/WSDL/Definitions.pm
+lib/SOAP/WSDL/Envelope.pm
+lib/SOAP/WSDL/Expat/MessageParser.pm
+lib/SOAP/WSDL/Expat/MessageStreamParser.pm
+lib/SOAP/WSDL/Message.pm
+lib/SOAP/WSDL/Operation.pm
+lib/SOAP/WSDL/OpMessage.pm
+lib/SOAP/WSDL/Parser.pod
+lib/SOAP/WSDL/Part.pm
+lib/SOAP/WSDL/Port.pm
+lib/SOAP/WSDL/PortType.pm
+lib/SOAP/WSDL/SAX/MessageHandler.pm
+lib/SOAP/WSDL/SAX/WSDLHandler.pm
+lib/SOAP/WSDL/Service.pm
+lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
+lib/SOAP/WSDL/SoapOperation.pm
+lib/SOAP/WSDL/TypeLookup.pm
+lib/SOAP/WSDL/Types.pm
+lib/SOAP/WSDL/XSD/ComplexType.pm
+lib/SOAP/WSDL/XSD/Element.pm
+lib/SOAP/WSDL/XSD/Primitive.pm
+lib/SOAP/WSDL/XSD/Schema.pm
+lib/SOAP/WSDL/XSD/Schema/Builtin.pm
+lib/SOAP/WSDL/XSD/SimpleType.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/anyType.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/boolean.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/byte.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/date.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/decimal.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/double.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/duration.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/float.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/gDay.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonth.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonthDay.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/gYear.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/gYearMonth.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/ID.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/int.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/integer.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/language.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/list.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/long.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/Name.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/NCName.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/QName.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/short.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/string.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/time.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/token.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.pm
+lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.pm
+lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm
+lib/SOAP/WSDL/XSD/Typelib/Element.pm
+lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
+LICENSE
+MANIFEST
 META.yml
 README
-t/1_performance.t
-t/2_helloworld.NET.t
-t/3_various.t
-t/97_pod.t
-t/98_pod_coverage.t
-t/acceptance/helloworld.asmx.xml
-t/acceptance/helloworld.xml
-t/acceptance/test.wsdl.xml
+t/001_use.t
+t/002_sax.t
+t/003_sax_serializer.t
+t/004_sax_wsdl.t
+t/005_sax_contributed_wsdl.t
+t/006_client.t
+t/007_envelope.t
+t/008_client_wsdl_complexType.t
+t/009_data_classes.t
+t/011_simpleType.t
+t/012_element.t
+t/013_complexType.t
+t/014_sax_typelib.t
+t/015_to_typemap.t
+t/016_client_object.t
+t/017_generator.t
+t/020_storable.t
+t/098_pod.t
+t/acceptance/results/03_complexType-all.xml
+t/acceptance/results/03_complexType-sequence.xml
+t/acceptance/results/04_element-simpleType.xml
+t/acceptance/results/04_element.xml
+t/acceptance/results/05_simpleType-list.xml
+t/acceptance/results/05_simpleType-restriction.xml
+t/acceptance/results/05_simpleType-union.xml
+t/acceptance/results/11_helloworld.xml
+t/acceptance/wsdl/006_sax_client.wsdl
+t/acceptance/wsdl/008_complexType.wsdl
+t/acceptance/wsdl/02_port.wsdl
+t/acceptance/wsdl/03_complexType-all.wsdl
+t/acceptance/wsdl/03_complexType-sequence.wsdl
+t/acceptance/wsdl/04_element-simpleType.wsdl
+t/acceptance/wsdl/04_element.wsdl
+t/acceptance/wsdl/05_simpleType-list.wsdl
+t/acceptance/wsdl/05_simpleType-restriction.wsdl
+t/acceptance/wsdl/05_simpleType-union.wsdl
+t/acceptance/wsdl/10_helloworld.asmx.xml
+t/acceptance/wsdl/11_helloworld.wsdl
+t/acceptance/wsdl/contributed/Axis.wsdl
+t/acceptance/wsdl/contributed/ETest.wsdl
+t/acceptance/wsdl/contributed/OITest.wsdl
+t/acceptance/wsdl/contributed/tools.wsdl
+t/acceptance/wsdl/email_account.wsdl
+t/Expat/01_expat.t
+t/lib/MyComplexType.pm
+t/lib/MyElement.pm
+t/lib/MySimpleType.pm
+t/lib/Test/SOAPMessage.pm
+t/lib/Typelib/Base.pm
+t/lib/Typelib/TEnqueueMessage.pm
+t/lib/Typelib/TMessage.pm
+t/SOAP/WSDL/01_use.t
+t/SOAP/WSDL/02_port.t
+t/SOAP/WSDL/03_complexType-all.t
+t/SOAP/WSDL/03_complexType-choice.t
+t/SOAP/WSDL/03_complexType-complexContent.t
+t/SOAP/WSDL/03_complexType-group.t
+t/SOAP/WSDL/03_complexType-sequence.t
+t/SOAP/WSDL/03_complexType-simpleContent.t
+t/SOAP/WSDL/04_element-complexType.t
+t/SOAP/WSDL/04_element-simpleType.t
+t/SOAP/WSDL/04_element.t
+t/SOAP/WSDL/05_simpleType-list.t
+t/SOAP/WSDL/05_simpleType-restriction.t
+t/SOAP/WSDL/05_simpleType-union.t
+t/SOAP/WSDL/10_performance.t
+t/SOAP/WSDL/11_helloworld.NET.t
+t/SOAP/WSDL/12_binding.pl
+t/SOAP/WSDL/XSD/Typelib/Builtin/001_string.t
--- a/META.yml
+++ b/META.yml
@@ -1,22 +1,183 @@
 ---
 name: SOAP-WSDL
-version: 1.21
+version: 2.00_06
 author:
-  - |-
-    Martin Kutter <martin.kutter@fen-net.de>
-    Giovanni S. Fois giovannisfois@tiscali.it
-abstract: WSDL support for SOAP::Lite
+abstract: SOAP with WSDL support
 license: artistic
-resources:
-  license: http://opensource.org/licenses/artistic-license.php
 requires:
-  SOAP::Lite: 0.55
+  Class::Std: v0.0.8
+  Class::Std::Storable: 0
+  File::Basename: 0
+  File::Path: 0
+  List::Util: 0
+  SOAP::Lite: 0
+  XML::LibXML: 0
+  XML::Parser::Expat: 0
+  XML::SAX::Base: 0
+  XML::SAX::ParserFactory: 0
  XML::XPath: 0
-provides:
-  SOAP::WSDL:
-    file: lib/SOAP/WSDL.pm
-    version: 1.21
-generated_by: Module::Build version 0.28
+generated_by: Module::Build version 0.2808
 meta-spec:
  url: http://module-build.sourceforge.net/META-spec-v1.2.html
  version: 1.2
+provides:
+  SOAP::WSDL:
+    file: lib/SOAP/WSDL.pm
+    version: 2.00_05
+  SOAP::WSDL::Base:
+    file: lib/SOAP/WSDL/Base.pm
+  SOAP::WSDL::Binding:
+    file: lib/SOAP/WSDL/Binding.pm
+  SOAP::WSDL::Client:
+    file: lib/SOAP/WSDL/Client.pm
+  SOAP::WSDL::Client::Base:
+    file: lib/SOAP/WSDL/Client/Base.pm
+    version: 0.1
+  SOAP::WSDL::Definitions:
+    file: lib/SOAP/WSDL/Definitions.pm
+  SOAP::WSDL::Envelope:
+    file: lib/SOAP/WSDL/Envelope.pm
+  SOAP::WSDL::Expat::MessageParser:
+    file: lib/SOAP/WSDL/Expat/MessageParser.pm
+  SOAP::WSDL::Expat::MessageStreamParser:
+    file: lib/SOAP/WSDL/Expat/MessageStreamParser.pm
+  SOAP::WSDL::Message:
+    file: lib/SOAP/WSDL/Message.pm
+  SOAP::WSDL::OpMessage:
+    file: lib/SOAP/WSDL/OpMessage.pm
+  SOAP::WSDL::Operation:
+    file: lib/SOAP/WSDL/Operation.pm
+  SOAP::WSDL::Part:
+    file: lib/SOAP/WSDL/Part.pm
+  SOAP::WSDL::Port:
+    file: lib/SOAP/WSDL/Port.pm
+  SOAP::WSDL::PortType:
+    file: lib/SOAP/WSDL/PortType.pm
+  SOAP::WSDL::SAX::MessageHandler:
+    file: lib/SOAP/WSDL/SAX/MessageHandler.pm
+  SOAP::WSDL::SOAP::Typelib::Fault11:
+    file: lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
+  SOAP::WSDL::Service:
+    file: lib/SOAP/WSDL/Service.pm
+  SOAP::WSDL::SoapOperation:
+    file: lib/SOAP/WSDL/SoapOperation.pm
+  SOAP::WSDL::TypeLookup:
+    file: lib/SOAP/WSDL/TypeLookup.pm
+  SOAP::WSDL::Types:
+    file: lib/SOAP/WSDL/Types.pm
+  SOAP::WSDL::XSD::ComplexType:
+    file: lib/SOAP/WSDL/XSD/ComplexType.pm
+  SOAP::WSDL::XSD::Element:
+    file: lib/SOAP/WSDL/XSD/Element.pm
+  SOAP::WSDL::XSD::Primitive:
+    file: lib/SOAP/WSDL/XSD/Primitive.pm
+  SOAP::WSDL::XSD::Schema:
+    file: lib/SOAP/WSDL/XSD/Schema.pm
+  SOAP::WSDL::XSD::Schema::Builtin:
+    file: lib/SOAP/WSDL/XSD/Schema/Builtin.pm
+  SOAP::WSDL::XSD::SimpleType:
+    file: lib/SOAP/WSDL/XSD/SimpleType.pm
+  SOAP::WSDL::XSD::Typelib::Builtin:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::ENTITY:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::ID:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/ID.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::IDREF:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::IDREFS:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::NCName:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/NCName.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::NOTATION:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::Name:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/Name.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::QName:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/QName.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::anyType:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/anyType.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::anyURI:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::base64Binary:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::boolean:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/boolean.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::byte:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/byte.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::date:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/date.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::dateTime:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::decimal:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/decimal.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::double:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/double.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::duration:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/duration.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::float:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/float.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::gDay:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/gDay.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::gMonth:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonth.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonthDay.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::gYear:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/gYear.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/gYearMonth.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::hexBinary:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::int:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/int.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::integer:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/integer.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::language:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/language.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::list:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/list.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::long:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/long.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::normalizedString:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::short:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/short.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::string:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/string.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::time:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/time.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::token:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/token.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.pm
+  SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort:
+    file: lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.pm
+  SOAP::WSDL::XSD::Typelib::ComplexType:
+    file: lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm
+  SOAP::WSDL::XSD::Typelib::Element:
+    file: lib/SOAP/WSDL/XSD/Typelib/Element.pm
+  SOAP::WSDL::XSD::Typelib::SimpleType:
+    file: lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
+  SOAP::WSDL::XSD::Typelib::SimpleType::restriction:
+    file: lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
+resources:
+  license: http://opensource.org/licenses/artistic-license.php
--- a/36
+++ b/36
@@ -1,34 +1,2 @@
-SOAP::WSDL - a WSDL-driven message preprocessor for SOAP::Lite.
-
-DESCRIPTION
-
-See "perldoc SOAP::WSDL" (or "perldoc WSDL.pm") for details.
-
-
-PREREQUISITES
-
-SOAP::WSDL requires the following perl modules:
-
- SOAP::Lite
- XML::XPath
-
-
-If you want to use file system caching (improves performance), you also 
-need the following packages:
-
- Cache::Cache
-
-INSTALLING
-
-Use the usual mantra:
-
-perl Makefile.PL
-make
-make test
-make install
-
-
-LICENSE
-
-This library is free software, you can distribute/modify it under the same 
-terms as perl itself.
+This is a developer release - everything may (and most things will) change.
+
--- a/lib/SOAP/WSDL.pm
+++ b/lib/SOAP/WSDL.pm
--- a/lib/SOAP/WSDL/Base.pm
+++ b/lib/SOAP/WSDL/Base.pm
@@ -0,0 +1,169 @@
+package SOAP::WSDL::Base;
+use strict;
+use warnings;
+use Carp;
+use Class::Std::Storable;
+use List::Util qw(first);
+
+my %id_of :ATTR(:name<id> :default<()>);
+my %name_of :ATTR(:name<name> :default<()>);
+my %targetNamespace_of :ATTR(:name<targetNamespace> :default<()>);
+my %xmlns_of :ATTR(:name<xmlns> :default<{}>);
+my %parent_of :ATTR(:name<parent> :default<()>);
+
+sub DEMOLISH {
+  my $self = shift;
+  # delete upward references
+  delete $parent_of{ ident $self };
+}
+
+sub STORABLE_freeze_pre :CUMULATIVE {};
+sub STORABLE_freeze_post :CUMULATIVE {};
+sub STORABLE_thaw_pre :CUMULATIVE {};
+sub STORABLE_thaw_post :CUMULATIVE { return $_[0] };
+
+# unfortunately, AUTOMETHOD is SLOW.
+# Re-implement in derived package wherever speed is an issue...
+#
+sub AUTOMETHOD {
+    my ($self, $ident, @values) = @_;
+    my $subname = $_;   # Requested subroutine name is passed via $_
+
+    # we're called as $self->push_something(@values);
+    if ($subname =~s{^push_}{}xms) {
+        my $getter = "get_$subname";
+        my $setter = "set_$subname";
+        ## Checking here is paranoid - will fail fatally if 
+        ## there is no setter...
+        ## And we would have to check getters, too.
+        ## Maybe do it the Conway way via the Symbol table...
+        ## ... can is way slow...
+        # croak "no set accessor found for push_$subname"
+        #    if not ($self->can( $setter ));
+        return sub {
+            no strict qw(refs);
+            my $old_value = $self->$getter();
+            # Listify if not a list ref
+            $old_value = $old_value ? [ $old_value ] : [] if not ref $old_value;
+
+            push @$old_value , @values;
+            $self->$setter( $old_value );
+        };
+    }
+
+    # we're called as $obj->find_something($ns, $key)
+    elsif ($subname =~s {^find_}{get_}xms) {
+        return sub {
+            return first {
+                $_->get_targetNamespace() eq $values[0] &&
+                $_->get_name() eq $values[1]
+            }
+            @{ $self->$subname() };
+        }
+    }
+    elsif ($subname =~s {^first_}{get_}xms) {
+        return sub {
+            my $result_ref = $self->$subname();
+            return if not $result_ref;
+            return $result_ref if (not ref $result_ref eq 'ARRAY');
+            return $result_ref->[0];
+        };
+    }
+    croak "$subname not found in class " . (ref $self || $self);
+}
+
+sub init {
+    my $self = shift;
+    my @args = @_;
+    foreach my $value (@args)
+    {
+        die $value if (not defined ($value->{ Name }));
+        if ($value->{ Name } =~m{^xmlns\:}xms) {
+            die $xmlns_of{ ident $self }
+                if ref $xmlns_of{ ident $self } ne 'HASH';
+            $xmlns_of{ ident $self }->{ $value->{ Value } } =
+                $value->{ LocalName };
+            next;
+        }
+        elsif ($value->{ Name } =~m{^xmlns$}xms) {
+            # just ignore xmlns = for now
+            # TODO handle xmlns correctly - maybe via setting a prefix ?
+            next;
+        }
+    my $name = $value->{ LocalName };
+    my $method = "set_$name";
+        $self->$method( $value->{ Value } )	if ( $method );
+    }
+    return $self;
+}
+
+sub add_namespace {
+    my ($self, $uri, $prefix ) = @_;
+    return unless $uri;
+    $self->{ namespace } ||= {};
+    $self->{ namespace }->{ $uri } = $prefix;
+}
+
+sub to_typemap {
+    warn "to_typemap";
+    return q{};
+}
+
+sub toClass {
+    my $self = shift;
+    warn 'toClass is deprecated and will be removed before reaching 2.01 - ' 
+        . 'use to_class instead (' . caller() . ')';
+    $self->to_class(@_);
+}
+
+sub to_class {
+    my $self = shift;
+    my $opt = shift;
+    my $template = shift;
+
+    $opt->{ base_path } ||= '.';
+
+    my $element_prefix = $opt->{ element_prefix } || $opt->{ prefix };
+    my $type_prefix = $opt->{ type_prefix } || $opt->{ prefix };
+    
+    if (($type_prefix) && ($type_prefix !~m{ :: $ }xms ) )  {
+      warn 'type_prefix should end with "::"';
+      $type_prefix .= '::';
+    }
+
+    if (($element_prefix) && ($element_prefix !~m{ :: $ }xms) ) {
+      warn 'element_prefix should end with "::"';
+      $element_prefix .= '::';
+    }
+
+    # Be careful: a Element may be ComplexType, too 
+    # (but not vice versa)
+    my $prefix = $self->isa('SOAP::WSDL::XSD::Element') 
+      ? $element_prefix
+      : $type_prefix;
+
+    die 'No prefix specified' if not $prefix;
+
+    my $filename = $prefix . $self->get_name() . '.pm';
+    $filename =~s{::}{/}xmsg;
+
+    my $output = $opt->{ output } || $filename; 
+
+    require Template;
+    my $tt = Template->new(
+            RELATIVE => 1,    
+            OUTPUT_PATH => $opt->{ base_path },
+    );
+    
+    my $code = $tt->process( \$template, {
+            element_prefix => $element_prefix,
+            type_prefix => $type_prefix,
+            self => $self, 
+            nsmap => { reverse %{ $opt->{ wsdl }->get_xmlns() } },
+            structure => $self->explain( { wsdl => $opt->{ wsdl } } ),
+        }, 
+        $output
+    )
+    or die $tt->error();
+}
+1;
--- a/lib/SOAP/WSDL/Binding.pm
+++ b/lib/SOAP/WSDL/Binding.pm
@@ -0,0 +1,115 @@
+package SOAP::WSDL::Binding;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %operation_of    :ATTR(:name<operation> :default<()>);
+my %type_of         :ATTR(:name<type> :default<()>);
+my %transport_of    :ATTR(:name<transport> :default<()>);
+my %style_of        :ATTR(:name<style> :default<()>);
+
+
+sub explain {
+    my $self = shift;
+    my $opt = shift;
+    my $name = $self->get_name();
+
+    die 'required atribute wsdl missing' if not $opt->{ wsdl };
+
+    my $portType = $opt->{ wsdl }->find_portType(
+        $opt->{ wsdl }->_expand( $self->get_type() )
+    ) or die 'portType not found: ' . $self->get_type();
+
+    my $txt = <<"EOT";
+ Transport: $transport_of{ ident $self }
+
+=head2 METHODS 
+
+B<Note:>
+
+ Input, output and fault messages are stated as perl hash refs. 
+ 
+ These are only for informational purposes - the  actual implementation 
+ may be object trees, not hash refs, though the input messages may be passed 
+ to the respective methods as hash refs and will be converted to object trees 
+ automatically.
+
+EOT
+
+    foreach my $operation (@{ $self->get_operation() }) {
+
+        my $operation_name = $operation->get_name();
+        my $operation_style = $operation->get_style() || q{};
+
+        my ($port_operation) = grep { $_->get_name eq $operation_name } 
+            @{ $portType->get_operation() }             
+                or die "operation not found:" . $operation->get_name();
+
+        # TODO rename lexical $input to "message"
+        my $input_message = do {
+            my $input = $port_operation->first_input();
+            $input ? $input->explain($opt) : q{};
+        };
+        my $output_message = do {
+            my $input = $port_operation->first_output();
+            $input ? $input->explain($opt) : q{};
+        };
+        my $fault_message = do {
+            my $input = $port_operation->first_fault();
+            $input ? $input->explain($opt) : q{};
+        };
+
+        $txt .= <<"EOT";
+
+=head3 $operation_name
+
+B<Input Message:>
+
+$input_message
+
+B<Output Message:>
+
+$output_message
+
+B<Fault:>
+
+$fault_message
+
+EOT
+    }
+
+    return $txt;
+}
+
+sub to_typemap {
+    my ($self, $opt) = @_;
+    my $name = $self->get_name();
+
+    my $portType = $opt->{ wsdl }->find_portType(
+        $opt->{ wsdl }->_expand( $self->get_type )
+    ) or die 'portType not found: ' . $self->get_type;
+
+    my $txt = q{};
+    foreach my $operation (@{ $self->get_operation() })
+    {
+        my $operation_name = $operation->get_name();
+        my $operation_style = $operation->get_style() || q{};
+
+        my ($port_operation) = grep { $_->get_name eq $operation_name } 
+            @{ $portType->get_operation() }             
+                or die "operation not found:" . $operation->get_name();
+
+        no strict qw(refs);
+        $txt .= join q{},
+            map { 
+                my $message = $port_operation->$_;
+                $message 
+                    ? $message->to_typemap($opt) 
+                    : q{}
+            } qw(first_input first_output first_fault);
+    }
+    return $txt;
+}
+
+1;
--- a/lib/SOAP/WSDL/Client.pm
+++ b/lib/SOAP/WSDL/Client.pm
@@ -0,0 +1,202 @@
+package SOAP::WSDL::Client;
+use strict;
+use warnings;
+use Carp;
+use Scalar::Util qw(blessed);
+use SOAP::WSDL::Envelope;
+use SOAP::Lite;
+use Class::Std::Storable;
+use SOAP::WSDL::Expat::MessageParser;
+use SOAP::WSDL::SOAP::Typelib::Fault11;
+
+# Package globals for speed...
+my $PARSER;
+my $MESSAGE_HANDLER;
+
+my %class_resolver_of   :ATTR(:name<class_resolver> :default<()>);
+my %no_dispatch_of      :ATTR(:name<no_dispatch>    :default<()>);
+my %outputxml_of        :ATTR(:name<outputxml>      :default<()>);
+my %proxy_of            :ATTR(:name<proxy>          :default<()>);
+
+# TODO remove when preparing 2.01
+sub outputtree { warn 'outputtree is deprecated and'
+    . 'will be removed before reaching v2.01 !' }
+
+SUBFACTORY: {
+    no strict qw(refs);
+    for (qw(class_resolver no_dispatch outputxml proxy)) {
+        my $setter = "set_$_";
+        my $getter = "get_$_";
+        *{ $_ } = sub { my $self = shift;
+            if (@_) {
+                $self->$setter(@_);
+                return $self;
+            }
+            return $self->$getter()
+        };
+    }
+}
+
+BEGIN {
+    $PARSER = SOAP::WSDL::Expat::MessageParser->new();
+}
+
+sub call {
+	my $self = shift;
+	my $method = shift;
+	my $data = ref $_[0] ? $_[0] : { @_ };
+    my $content = q{};
+    my ($envelope, $soap_action);
+
+	if (blessed $data
+        && $data->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType'))
+    {
+        $envelope = SOAP::WSDL::Envelope->serialize( $method, $data );
+
+        # TODO replace by something derived from binding - this is just a
+        # workaround...
+        $soap_action = join '/', $data->get_xmlns(), $method;
+
+    }
+
+	return $envelope if $self->no_dispatch();
+
+    # warn $envelope;
+
+	# get response via transport layer
+	# TODO remove dependency from SOAP::Lite and use a
+    # SAX-based filter using XML::LibXML to get the
+    # result.
+    # Filter should have the following methods:
+    # - result: returns the result of the call (like SOAP::Lite, but as
+    #           perl data structure)
+    # - header: returns the content of the SOAP header
+    # - fault:  returns the result of the call if a SOAP fault is sent back
+    #           by the server. Retuns undef (nothing) if the call has been
+    #           processed without errors.
+    my $soap = SOAP::Lite->new()->proxy( $self->get_proxy() );
+	my $response = $soap->transport->send_receive(
+		context  => $self,              # this is provided for context
+		endpoint => $soap->endpoint(),
+		action   => $soap_action,       # SOAPAction, should be from binding
+		envelope => $envelope,          # use custom content
+	);
+
+    # warn 'Received ' . length($response) . ' bytes of content';
+	return $response if ($self->outputxml() );
+
+    $PARSER->class_resolver( $self->get_class_resolver() );
+
+    # if we had no success (Transport layer error status code)
+    # or if transport layer failed
+    if (! $soap->transport->is_success() ) {
+        # Try deserializing response - there may be some
+        if ($response) {
+            eval { $PARSER->parse( $response ); };           
+            if ($@) {
+                warn "could not deserialize response: $@";                    
+            }
+            else {   
+                return $MESSAGE_HANDLER->get_data();
+            }
+        };
+        
+
+        require SOAP::WSDL::SOAP::Typelib::Fault11;
+        # generate & return fault if we cannot serialize response
+        # or have none...
+        return SOAP::WSDL::SOAP::Typelib::Fault11->new({
+            faultcode => 'soap:Server',
+            faultactor => 'urn:localhost',
+            faultstring => 'Error sending / receiving message: '
+                . $soap->transport->message()
+        });
+    }
+    eval { $PARSER->parse( $response ) };
+
+    # return fault if we cannot deserialize response
+    if ($@) {
+        return SOAP::WSDL::SOAP::Typelib::Fault11->new({
+            faultcode => 'soap:Server',
+            faultactor => 'urn:localhost',
+            faultstring => "Error deserializing message: $@. \n"
+                . "Message was: \n$response"
+        });
+    }
+
+    return $PARSER->get_data();
+} ## end sub call
+
+1;
+
+=pod
+
+=head2 Features different from SOAP::Lite
+
+SOAP::WSDL does not aim to be a complete replacement for SOAP::Lite - the
+SOAP::Lite module has it's strengths and weaknesses and SOAP::WSDL is
+designed as a cure for the weakness of little WSDL support - nothing more,
+nothing less.
+
+Nonetheless SOAP::WSDL mimics part of SOAP::Lite's API and behaviour,
+so SOAP::Lite users can switch without looking up every method call in the
+documentation.
+
+A few things are quite differentl from SOAP::Lite, though:
+
+=head3 SOAP request data
+
+SOAP request data may either be given as message object, or as hash ref (in
+which case it will automatically be encoded into a message object).
+
+=head3 Return values
+
+The result from call() is not a SOAP::SOM object, but a message object.
+
+Message objects' classes may be generated from WSDL definitions automatically
+- see SOAP::WSDL::Generator::Typelib on how to generate your own WSDL based
+message class library.
+
+=head3 Fault handling
+
+SOAP::WSDL::Client returns a fault object on errors, even on transport layer
+errors.
+
+The fault object is a SOAP1.1 fault object of the following
+C<SOAP::WSDL::SOAP::Typelib::Fault11>.
+
+SOAP::WSDL::SOAP::Typelib::Fault11 objects are false in boolean context, so
+you can just do something like
+
+ my $result = $soap->call($method, $data);
+
+ if ($result) {
+    # handle result
+ }
+ else {
+    die $result->faultstring();
+ }
+
+=head3 outputxml
+
+SOAP::Lite returns only the content of the SOAP body when outputxml is set
+to true. SOAP::WSDL::Client returns the complete XML response.
+
+=head3 Auto-Dispatching
+
+SOAP::WSDL::Client does B<does not> support auto-dispatching.
+
+This is on purpose: You may easily create interface classes by using
+SOAP::WSDL::Client and implementing something like
+
+ sub mySoapMethod {
+     my $self = shift;
+     $soap_wsdl_client->call( mySoapMethod, @_);
+ }
+
+You may even do this in a class factory - SOAP::WSDL provides the methods
+for generating such interfaces.
+
+=cut
+
+
--- a/lib/SOAP/WSDL/Client/Base.pm
+++ b/lib/SOAP/WSDL/Client/Base.pm
@@ -0,0 +1,127 @@
+#!/usr/bin/perl -w
+package SOAP::WSDL::Client::Base;
+
+################################################################################## 
+## <OWNER>Internetteam
+## <AUTHOR>Martin Kutter <martin.kutter@siemens.com>
+## <CREATIONDATE>25.10.2006
+##
+## <FUNCTION>Base client for WSDL-based SOAP access
+## Automatisch gefüllt:
+## <CVSPROJECT>$HeadURL:$
+## <REVISION>$Revision:$
+################################################################################
+
+use strict;
+use Log::Log4perl;
+
+use Class::Accessor;
+
+use base qw/Class::Accessor/;
+
+$SOAP::WSDL::Client::Base::VERSION = sprintf("0.%d", q$LastChangedRevision: 1$ =~/(\d+)/ );
+
+__PACKAGE__->mk_accessors( 
+	qw// 
+);
+
+my $log = undef;	# Global logger to speed up performance
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::Client::Base - Base client for WSDL-based SOAP access
+
+=head1 SYNOPSIS
+
+ use SOAP::WSDL::Client::Base;
+
+# TODO Add more Synopsis information
+
+=head1 DESCRIPTION
+
+# TODO Add Description
+
+=cut
+
+=pod
+
+=head2 new
+
+=over
+
+=item SYNOPSIS
+
+ my $obj = ->new();
+
+=item DESCRIPTION
+
+Constructor.
+
+=back
+
+=cut
+
+sub new
+{
+	my $proto = shift;
+	my $class = ref $proto || $proto;
+	my $self = {
+			soapBindingStyle => 'rpc',
+		};
+	bless $self, $class;
+	$self->init(@_);
+	return $self;
+}
+
+sub soapBindingStyle
+{
+	my $self = shift;
+	my $style = shift;
+	if ($style)
+	{
+		die "Binding style must be one of rpc|document" 
+			if (not( $style=~m/^(rpc|document)$/));
+		$self->{ soapBindingStyle } = $style;
+	}
+	return $self->{ soapBindingStyle };
+}
+
+sub init
+{
+}
+
+sub call
+{
+	my $self = shift;
+	my $method = shift;
+	my $data = shift;
+	my $content;
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 AUTHOR
+
+Martin Kutter <martin.kutter@siemens.com>
+
+=head1 COPYING
+
+Copyright (c) 2005 SIEMENS AG. All rights reserved.
+
+=head1 Repository information
+
+ $ID: $
+
+ $LastChangedDate: $
+ $LastChangedRevision: $
+ $LastChangedBy: $
+
+ $HeadURL: $
+
+=cut
--- a/lib/SOAP/WSDL/Definitions.pm
+++ b/lib/SOAP/WSDL/Definitions.pm
@@ -0,0 +1,353 @@
+package SOAP::WSDL::Definitions;
+use strict;
+use warnings;
+use Carp;
+use File::Basename;
+use File::Path;
+use List::Util qw(first);
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %types_of    :ATTR(:name<types>      :default<[]>);
+my %message_of  :ATTR(:name<message>    :default<()>);
+my %portType_of :ATTR(:name<portType>   :default<()>);
+my %binding_of  :ATTR(:name<binding>    :default<()>);
+my %service_of  :ATTR(:name<service>    :default<()>);
+my %namespace_of  :ATTR(:name<namespace> :default<()>);
+
+# must be attr for Class::Std::Storable
+my %attributes_of :ATTR();      
+%attributes_of = (
+    binding => \%binding_of,
+    message => \%message_of,
+    portType => \%portType_of,
+    service => \%service_of,
+);
+
+# Function factory - we could be writing this method for all %attribute
+# keys, too, but that's just C&P (eehm, Copy & Paste...)
+BLOCK: {    
+  no strict qw/refs/;
+  foreach my $method(keys %attributes_of ) {
+  
+      *{ "find_$method" } = sub {
+          my ($self, @args) = @_;
+          return first { 
+                  $_->get_targetNamespace() eq $args[0] 
+                  && $_->get_name() eq $args[1] 
+              }
+              @{ $attributes_of{ $method }->{ ident $self } };
+      };
+  }
+}
+
+sub explain {
+    my $self = shift;
+    my $opt = shift;
+    $opt->{ wsdl } ||= $self;
+    $opt->{ namespace } ||= $self->get_xmlns() || {};
+    my $txt = '';
+
+    for my $service (@{ $self->get_service() }) {
+        $txt .= $service->explain( $opt );
+        $txt .= "\n";
+    }
+    return $txt;
+}
+
+sub _expand {
+    my ($self, $prefix, $localname) = ($_[0], split /:/, $_[1]);
+    my %ns_map = reverse %{ $self->get_xmlns() };
+    return ($ns_map{ $prefix }, $localname);
+}
+
+sub to_typemap {
+    my $self = shift;
+    my $opt = shift;
+    $opt->{ prefix } ||= q{};
+    $opt->{ wsdl } ||= $self;
+    $opt->{ type_prefix } ||= $opt->{ prefix };
+    $opt->{ element_prefix } ||= $opt->{ prefix };
+    return  join "\n",
+        map { $_->to_typemap( $opt ) } @{ $service_of{ ident $self } };
+}
+
+sub create_interface {
+    my $self = shift;
+    my $opt = shift;
+ 
+    my $base_path = $opt->{ base_path } 
+      or croak "missing or empty argument base_path";
+    $opt->{ prefix } ||= q{};
+    $opt->{ type_prefix } ||= $opt->{ prefix };
+    $opt->{ element_prefix } ||= $opt->{ prefix };
+    $opt->{ typemap_prefix } or die 'Required argument typemap_prefix missing';
+   
+    mkpath $base_path;
+
+    for my $service (@{ $service_of{ ident $self } }) {
+      warn "creating typemap $opt->{ typemap_prefix }". $service->get_name() . "\n";
+      $self->_create_typemap({ %{ $opt }, service => $service });
+    }
+
+    my @schema = @{ $self->first_types()->get_schema() };
+    for my $type (map { @{ $_->get_type() } , @{ $_->get_element() } } @schema[1..$#schema] ) {
+        warn 'creating class for '. $type->get_name() . "\n";
+        $type->to_class( { %$opt, wsdl => $self } );
+    }
+    1;
+}
+
+sub _create_typemap {
+    my $self = shift;
+    my $opt = shift;
+    my $service_name = $opt->{ service }->get_name();
+    my $file_name = "$opt->{ base_path }/$opt->{ typemap_prefix }/$service_name.pm";
+    $file_name =~s{::}{/}gms;
+    my $path = dirname $file_name;
+    my $name = basename $file_name;
+ 
+    my $typemap = $opt->{ service }->to_typemap( { %{ $opt }, wsdl => $self } );
+    
+    my $template = <<'EOT';
+package [% typemap_prefix %][% service.get_name %];
+use strict;
+use warnings;
+
+my %typemap = (
+[% typemap %]
+[% custom_types %]
+);
+
+sub get_class { 
+  my $name = join '/', @{ $_[1] };
+  exists $typemap{ $name } or die "Cannot resolve $name via " . __PACKAGE__;
+  return $typemap{ $name };
+}
+
+1;
+
+__END__
+
+EOT
+
+    require Template;
+    my $tt = Template->new(
+      OUTPUT_PATH => $path,
+    );
+    $tt->process(\$template, { %{ $opt }, typemap => $typemap }, $name)
+      or die $tt->error();
+
+}
+
+
+1;
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::Definitions - model a WSDL E<gt>definitionsE<lt> element
+
+=head1 DESCRIPTION
+
+=head1 METHODS
+
+=head2 first_service get_service set_service push_service
+
+Accessors/Mutators for accessing / setting the E<gt>serviceE<lt> child 
+element(s).
+
+=head2 find_service
+
+Returns the service matching the namespace/localname pair passed as arguments.
+
+ my $service = $wsdl->find_service($namespace, $localname);
+
+=head2 first_binding get_binding set_binding push_binding
+
+Accessors/Mutators for accessing / setting the E<gt>bindingE<lt> child 
+element(s).
+
+=head2 find_service
+
+Returns the binding matching the namespace/localname pair passed as arguments.
+
+ my $binding = $wsdl->find_binding($namespace, $localname);
+
+=head2 first_portType get_portType set_portType push_portType
+
+Accessors/Mutators for accessing / setting the E<gt>portTypeE<lt> child 
+element(s).
+
+=head2 find_portType
+
+Returns the portType matching the namespace/localname pair passed as arguments.
+
+ my $portType = $wsdl->find_portType($namespace, $localname);
+
+=head2 first_message get_message set_message push_message
+
+Accessors/Mutators for accessing / setting the E<gt>messageE<lt> child 
+element(s).
+
+=head2 find_service
+
+Returns the message matching the namespace/localname pair passed as arguments.
+
+ my $message = $wsdl->find_message($namespace, $localname);
+
+=head2 first_types get_types set_types push_types
+
+Accessors/Mutators for accessing / setting the E<gt>typesE<lt> child 
+element(s).
+
+=head2 explain
+
+Returns a POD string describing how to call the methods of the service(s) 
+described in the WSDL. 
+
+=head2 to_typemap
+
+Creates a typemap for use with a generated type class library.
+
+Options:
+
+ NAME            DESCRIPTION
+ -------------------------------------------------------------------------
+ prefix          Prefix to use for all classes
+ type_prefix     Prefix to use for all (Complex/Simple)Type classes
+ element_prefix  Prefix to use for all Element classes (with atomic types)
+
+As some webservices tend to use globally unique type definitions, but 
+locally unique elements with atomic types, type and element classes may 
+be separated by specifying type_prefix and element_prefix instead of 
+prefix.
+
+The typemap is plain text which can be used as snipped for building a 
+SOAP::WSDL class_resolver perl class.
+
+Try something like this for creating typemap classes: 
+
+ my $parser = XML::LibXML->new();
+ my $handler = SOAP::WSDL::SAX::WSDLHandler->new()
+ $parser->set_handler( $handler );
+ 
+ $parser->parse_url('file:///path/to/wsdl');
+
+ my $wsdl = $handler->get_data(); 
+ my $typemap = $wsdl->to_typemap();
+
+ print <<"EOT"
+ package MyTypemap;
+ my \%typemap = (
+  $typemap
+ );
+ sub get_class { return \$typemap{\$_[1] } };
+ 1;
+ "EOT"
+
+=head2 create_interface 
+
+Creates a typemap class, classes for all types and elements, and interface
+classes for every service.
+
+See L<CODE GENERATOR|CODE GENERATOR> below.
+
+Options:
+
+ Name             Description
+ ----------------------------------------------------------------------------
+ prefix           Prefix to use for types and elements. Should end with '::'.
+ element_prefix   Prefix to use for element packages. Should end with '::'.
+                  Must be specified if prefix is not given.
+ type_prefix      Prefix to use for type packages. Should end with '::'.
+                  Must be specified if prefix is not given.
+ typemap_prefix   Prefix to use for type packages. Should end with '::'.
+                  Mandatory.
+ custom_types     A perl source code snippet defining custom types for the 
+                  class resolver (typemap).
+                  Must look like this:
+ q{
+  'path/to/my/element' => 'My::Element',
+  'path/to/my/element/prop' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+  'path/to/my/element/prop2' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+ };
+
+=head2 _expand
+
+Expands a qualified name into a list consisting of namespace URI and 
+localname by using the definition's xmlns table.
+
+Used internally by SOAP::WSDL::* classes.
+
+=head1 CODE GENERATOR
+
+TODO: move somewhere else - maybe SOAP::WSDL::Client ?
+
+SOAP::WSDL::Definitions features a code generation facility for generating 
+perl classes (packages) from a WSDL definition.
+
+The following classes are generated:
+
+=over
+
+=item * Typemaps
+
+A typemap class is created for every service.
+
+Typemaps are basically lookup classes. They allow the 
+SOAP::WSDL::SAX::MessageHandler to find out which class a XML element 
+in a SOAP message shoud be processed as. 
+
+Typemaps are passed to SOAP::WSDL::Client via the class_resolver 
+method.
+
+=item * Interfaces
+
+TODO: Implement Interface generation
+
+Interface classes are just convenience shortcuts for accessing web 
+service methods. They define a method for every web service method, 
+dispatching the request to SOAP::WSDL::Client.
+
+=item * Type and Element classes
+
+For every top-level E<lt>elementE<gt>,  E<lt>complexTypeE<gt> and 
+E<lt>simpleTypeE<gt> definition in the WSDL's schema, a perl class is 
+created.
+
+Classes for E<lt>complexTypeE<gt> and E<lt>simpleTypeE<gt> definitions 
+are prefixed by the C<type_prefix> argument passed to 
+L<create_interface|create_interface>, classes for E<lt>elementE<gt> 
+definitions are prefixed by the C<element_prefix> passed to 
+L<create_interface|create_interface>. If the specific prefixes are not 
+specified, the C<prefix> argument is used instead.
+
+If your web service is part of a bigger framework which defines types 
+globally, you probably do well always using the same C<type_prefix>: 
+This reduces the number of classes generated (provided types 
+are re-used by more than one service).
+
+You probably should use different element prefixes, though - 
+E<lt>elementE<gt> definitions tend to be unique in the defining WSDL 
+only, especially when using document/literal style/encoding.
+
+If not, you probably want to specify just C<prefix> (and use a 
+different one for every web service).
+
+=back
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
+
--- a/lib/SOAP/WSDL/Envelope.pm
+++ b/lib/SOAP/WSDL/Envelope.pm
@@ -0,0 +1,66 @@
+#!/usr/bin/perl -w
+package SOAP::WSDL::Envelope;
+use strict;
+use base qw/SOAP::WSDL::Base/;
+
+my $SOAP_NS = 'http://schemas.xmlsoap.org/soap/envelope/';
+my $XML_INSTANCE_NS = 'http://www.w3.org/2001/XMLSchema-instance';
+
+sub serialize {
+    my ($self, $name, $data, $opt) = @_;
+
+    if (not $opt->{ namespace }->{ $SOAP_NS })
+    {
+        $opt->{ namespace }->{ $SOAP_NS } = 'SOAP-ENV';
+    }
+
+    if (not $opt->{ namespace }->{ $XML_INSTANCE_NS })
+    {
+        $opt->{ namespace }->{ $XML_INSTANCE_NS } = 'xsi';
+    }
+
+    my $soap_prefix = $opt->{ namespace }->{ $SOAP_NS };
+
+    # envelope start with namespaces
+    my $xml = "<$soap_prefix\:Envelope ";
+
+    while (my ($uri, $prefix) = each %{ $opt->{ namespace } })
+    {
+        $xml .= "\n\t" if ($opt->{'readable'});
+        $xml .= "xmlns:$prefix=\"$uri\" ";
+    }
+
+    # TODO insert encoding
+    $xml.='>';
+    $xml .= $self->serialize_header($name, $data, $opt);
+    $xml .= $self->serialize_body($name, $data, $opt);
+    $xml .= "\n" if ($opt->{ readable });
+    $xml .= '</' . $soap_prefix .':Envelope>';
+    $xml .= "\n" if ($opt->{ readable });
+    return $xml;
+}
+
+sub serialize_header {
+    my $xml = '';
+    return $xml;
+}
+
+sub serialize_body {
+    my $self = shift;
+    my $name = shift;
+    my $data = shift;
+    my $opt = shift;
+
+    my $soap_prefix = $opt->{ namespace }->{ $SOAP_NS };
+
+    my $xml = '';
+    $xml .= "\n" if ($opt->{ readable });
+    $xml .= "<$soap_prefix\:Body>";
+    $xml .= "\n" if ($opt->{ readable });
+
+    # include parts
+    $xml .= $data if ( defined($data) );
+
+    $xml .= "</$soap_prefix\:Body>";
+    return $xml;
+}
--- a/lib/SOAP/WSDL/Expat/MessageParser.pm
+++ b/lib/SOAP/WSDL/Expat/MessageParser.pm
@@ -0,0 +1,201 @@
+#!/usr/bin/perl
+package SOAP::WSDL::Expat::MessageParser;
+use strict;
+use warnings;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+use XML::Parser::Expat;
+
+=pod
+
+=head2 new
+
+=over
+
+=item SYNOPSIS
+
+ my $obj = ->new();
+
+=item DESCRIPTION
+
+Constructor.
+
+=back
+
+=cut
+
+sub new {
+    my $class = shift;
+    my $args = shift;
+    my $self = {
+        class_resolver => $args->{ class_resolver }
+    };
+    bless $self, $class;
+    return $self;
+}
+
+sub class_resolver {
+    my $self = shift;
+    $self->{ class_resolver } = shift;
+}
+
+sub parse {
+	my $self = shift;
+    my $xml = shift; 
+	$self->{ data } = undef;
+    
+    my $characters;
+    my $current = '__STOP__';
+    my $ignore = [ 'Envelope', 'Body' ];
+    my $list = [];
+    my $namespace = {};
+    my $path = [];
+    my $parser = XML::Parser::Expat->new();
+
+    no strict qw(refs);     
+    $parser->setHandlers(
+        Start => sub {
+            my ($parser, $element, %attrs) = @_;
+            my ($prefix, $localname) = split m{:}xms , $element;
+            # for non-prefixed elements
+            if (not $localname) {
+                $localname = $element;
+                $prefix = q{};
+            }
+            # ignore top level elements
+            if (@{ $ignore } && $localname eq $ignore->[0]) {
+                shift @{ $ignore };
+                return;
+            }
+            # empty characters
+            $characters = q{};
+    
+            push @{ $path }, $localname;  # step down...
+            push @{ $list }, $current;    # remember current
+    
+            # resolve class of this element
+            my $class = $self->{ class_resolver }->get_class( $path )
+                or die "Cannot resolve class for "
+                    . join('/', @{ $path }) . " via $self->{ class_resolver }";
+    
+            # Check whether we have a primitive - we implement them as classes
+            # TODO replace with UNIVERSAL->isa()
+            # match is a bit faster if the string does not match, but WAY slower 
+            # if $class matches...
+            # if (not $class=~m{^SOAP::WSDL::XSD::Typelib::Builtin}xms) {
+                
+            if (index $class, 'SOAP::WSDL::XSD::Typelib::Builtin', 0 < 0) {           
+
+                # check wheter there is a CODE reference for $class::new.
+                # If not, require it - all classes required here MUST
+                # define new()
+                # This is the same as $class->can('new'), but it's way faster  
+                *{ "$class\::new" }{ CODE } 
+                    or eval "require $class"   ## no critic qw(ProhibitStringyEval)
+                        or die $@;                        
+            }
+            # create object
+            # set current object
+            $current = $class->new({ %attrs });
+        
+            # remember top level element
+            defined $self->{ data } 
+                or ($self->{ data } = $current); 
+        },
+        Char => sub {
+            $characters .= $_[1];
+        },
+        End => sub {        
+            my $element = $_[1];
+
+            my ($prefix, $localname) = split m{:}xms , $element;
+            # for non-prefixed elements
+            if (not $localname) {
+                $localname = $element;
+                $prefix = q{};
+            }
+      
+            # This one easily handles ignores for us, too...
+            return if not ref $list->[-1];
+    
+            if ( $current
+                ->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType') ) {
+                $current->set_value( $characters );
+            }
+        
+            # set appropriate attribute in last element
+            # multiple values must be implemented in base class
+            my $method = "add_$localname";
+        
+            $list->[-1]->$method( $current );
+        
+            # step up in path
+            pop @{ $path };
+            
+            # step up in object hierarchy...
+            $current = pop @{ $list };
+        }
+    );
+    
+    $parser->parse( $xml );     
+}
+
+sub get_data {
+    my $self = shift;
+    return $self->{ data };
+}
+
+
+1;
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::Expat::MessageParser - Convert SOAP messages to custom object trees
+
+=head1 SYNOPSIS
+
+ my $parser = SOAP::WSDL::Expat::MessageParser->new({
+    class_resolver => 'My::Resolver'   
+ });
+ $parser->parse( $xml );
+ my $obj = $parser->get_data();
+
+=head1 DESCRIPTION
+
+Real fast expat based SOAP message parser.
+
+See L<SOAP::WSDL::Parser> for details.
+
+=head1 Bugs and Limitations
+
+=over
+
+=item * Ignores all namespaces
+
+=item * Does not handle mixed content
+
+=item * The SOAP header is ignored
+
+=back
+
+=head1 AUTHOR
+
+Replace the whitespace by @ for E-Mail Address.
+
+ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=head1 COPYING
+
+This module may be used under the same terms as perl itself.
+
+=head1 Repository information
+
+ $ID: $
+
+ $LastChangedDate: $
+ $LastChangedRevision: $
+ $LastChangedBy: $
+
+ $HeadURL: $
+
--- a/lib/SOAP/WSDL/Expat/MessageStreamParser.pm
+++ b/lib/SOAP/WSDL/Expat/MessageStreamParser.pm
@@ -0,0 +1,206 @@
+#!/usr/bin/perl
+package SOAP::WSDL::Expat::MessageStreamParser;
+use strict;
+use warnings;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+use XML::Parser::Expat;
+
+=pod
+
+=head2 new
+
+=over
+
+=item SYNOPSIS
+
+ my $obj = ->new();
+
+=item DESCRIPTION
+
+Constructor.
+
+=back
+
+=cut
+
+sub new {
+    my $class = shift;
+    my $self = {
+        class_resolver => shift->{ class_resolver }
+    };
+    bless $self, $class;
+    return $self;
+}
+
+sub class_resolver {
+    my $self = shift;
+    $self->{ class_resolver } = shift;
+}
+
+sub init {
+	my $self = shift;
+    my $xml = shift; 
+	$self->{ data } = undef;
+    
+    my $characters;
+    my $current = '__STOP__';
+    my $ignore = [ 'Envelope', 'Body' ];
+    my $list = [];
+    my $namespace = {};
+    my $path = [];
+    my $parser = XML::Parser::ExpatNB->new();
+
+    no strict qw(refs);     
+    $parser->setHandlers(
+        Start => sub {
+            my ($parser, $element, %attrs) = @_;
+            my ($prefix, $localname) = split m{:}xms , $element;
+            # for non-prefixed elements
+            if (not $localname) {
+                $localname = $element;
+                $prefix = q{};
+            }
+            # ignore top level elements
+            if (@{ $ignore } && $localname eq $ignore->[0]) {
+                shift @{ $ignore };
+                return;
+            }
+            # empty characters
+            $characters = q{};
+    
+            push @{ $path }, $localname;  # step down...
+            push @{ $list }, $current;    # remember current
+    
+            # resolve class of this element
+            my $class = $self->{ class_resolver }->get_class( $path )
+                or die "Cannot resolve class for "
+                    . join('/', @{ $path }) . " via $self->{ class_resolver }";
+    
+            # Check whether we have a primitive - we implement them as classes
+            # TODO replace with UNIVERSAL->isa()
+            # match is a bit faster if the string does not match, but WAY slower 
+            # if $class matches...
+            # if (not $class=~m{^SOAP::WSDL::XSD::Typelib::Builtin}xms) {
+                
+            if (index $class, 'SOAP::WSDL::XSD::Typelib::Builtin', 0 < 0) {           
+
+                # check wheter there is a CODE reference for $class::new.
+                # If not, require it - all classes required here MUST
+                # define new()
+                # This is the same as $class->can('new'), but it's way faster  
+                *{ "$class\::new" }{ CODE } 
+                    or eval "require $class"   ## no critic qw(ProhibitStringyEval)
+                        or die $@;                        
+            }
+            # create object
+            # set current object
+            $current = $class->new({ %attrs });
+        
+            # remember top level element
+            defined $self->{ data } 
+                or ($self->{ data } = $current); 
+        },
+        Char => sub {
+            $characters .= $_[1];
+        },
+        End => sub {        
+            my $element = $_[1];
+
+            my ($prefix, $localname) = split m{:}xms , $element;
+            # for non-prefixed elements
+            if (not $localname) {
+                $localname = $element;
+                $prefix = q{};
+            }
+      
+            # This one easily handles ignores for us, too...
+            return if not ref $list->[-1];
+    
+            if ( $current
+                ->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType') ) {
+                $current->set_value( $characters );
+            }
+        
+            # set appropriate attribute in last element
+            # multiple values must be implemented in base class
+            my $method = "add_$localname";
+        
+            $list->[-1]->$method( $current );
+        
+            # step up in path
+            pop @{ $path };
+            
+            # step up in object hierarchy...
+            $current = pop @{ $list };
+        }
+    );
+
+    return $parser;
+}
+
+sub get_data {
+    my $self = shift;
+    return $self->{ data };
+}
+
+
+1;
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::Expat::MessageStreamParser - Convert SOAP messages to custom object trees
+
+=head1 SYNOPSIS
+
+ my $lwp = LWP::UserAgent->new();
+
+ my $parser = SOAP::WSDL::Expat::MessageParser->new({
+    class_resolver => 'My::Resolver'   
+ });
+ my $chunk_parser = $parser->init();
+ # process response while it comes in, trying to read 32k chunks.
+ $lwp->request( $request, sub { $chunk_parser->parse_more($_[0]) } , 32468 );
+ $chunk_parser->parse_done();
+ 
+ my $obj = $parser->get_data();
+
+=head1 DESCRIPTION
+
+ExpatNB based parser for parsing huge documents.
+
+See L<SOAP::WSDL::Parser> for details.
+
+=head1 Bugs and Limitations
+
+=over
+
+=item * Ignores all namespaces
+
+=item * Does not handle mixed content
+
+=item * The SOAP header is ignored
+
+=back
+
+=head1 AUTHOR
+
+Replace the whitespace by @ for E-Mail Address.
+
+ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=head1 COPYING
+
+This module may be used under the same terms as perl itself.
+
+=head1 Repository information
+
+ $ID: $
+
+ $LastChangedDate: $
+ $LastChangedRevision: $
+ $LastChangedBy: $
+
+ $HeadURL: $
+
--- a/lib/SOAP/WSDL/Message.pm
+++ b/lib/SOAP/WSDL/Message.pm
@@ -0,0 +1,9 @@
+package SOAP::WSDL::Message;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %part_of :ATTR(:name<part> :default<[]>);
+
+1;
--- a/lib/SOAP/WSDL/OpMessage.pm
+++ b/lib/SOAP/WSDL/OpMessage.pm
@@ -0,0 +1,64 @@
+package SOAP::WSDL::OpMessage;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %body_of     :ATTR(:name<body> :default<()>);
+my %message_of  :ATTR(:name<message> :default<()>);
+my %use_of      :ATTR(:name<use> :default<()>);
+my %namespace   :ATTR(:name<namespace> :default<()>);
+my %encodingStyle_of :ATTR(:name<encodingStyle> :default<()>);
+
+sub explain
+{
+	my $self = shift;
+	my $opt = shift;
+	my $name = shift;
+	my $txt = '';
+
+	my %ns_map = reverse %{ $opt->{ wsdl }->get_xmlns() };
+
+	if ( $self->get_message() )	{
+
+		my ($prefix, $localname) = split /:/ , $self->get_message();
+
+        # TODO allow more messages && overloading by specifying name
+		my $message = $opt->{ wsdl }->get_message(
+			$ns_map{ $prefix }, $localname
+		);
+
+		for my $part(@{ $message->[0]->get_part() }) {
+			$txt .= $part->explain($opt);
+        }
+	}
+	else
+	{
+		if ($self->use())
+		{
+			$txt .= " $name use: " . $self->use(). "\n";
+		}
+	}
+	return $txt;
+}
+
+sub to_typemap {
+
+    my ($self, $opt) = @_;
+    my $txt = q{};
+    return q{} if not ( $self->get_message() ); # we're in binding
+    my %ns_map = reverse %{ $opt->{ wsdl }->get_xmlns() };
+    my ($prefix, $localname) = split /:/ , $self->get_message();
+
+    # TODO allow more messages && overloading by specifying name
+    my $message = $opt->{ wsdl }->find_message(
+        $ns_map{ $prefix }, $localname
+    );
+
+    for my $part(@{ $message->get_part() }) {
+         $txt .= $part->to_typemap($opt);
+    }
+    return $txt;
+}
+
+1;
--- a/lib/SOAP/WSDL/Operation.pm
+++ b/lib/SOAP/WSDL/Operation.pm
@@ -0,0 +1,18 @@
+package SOAP::WSDL::Operation;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw/SOAP::WSDL::Base/;
+
+my %operation_of :ATTR(:name<operation> :default<()>);
+my %input_of :ATTR(:name<input> :default<()>);
+my %output_of :ATTR(:name<output> :default<()>);
+my %fault_of :ATTR(:name<fault> :default<()>);
+my %type_of :ATTR(:name<type> :default<()>);
+my %style_of :ATTR(:name<style> :default<()>);
+my %transport_of :ATTR(:name<transport> :default<()>);
+my %parameterOrder_of :ATTR(:name<parameterOrder> :default<()>);
+
+1;
+
+
--- a/lib/SOAP/WSDL/Parser.pod
+++ b/lib/SOAP/WSDL/Parser.pod
@@ -0,0 +1,213 @@
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::Parser - How SOAP::WSDL parses XML messages
+
+=head1 Which XML message does SOAP::WSDL parse ?
+
+Naturally, there are two kinds of XMLdocuments (or messages) SOAP::WSDL 
+has to parse:
+
+=over
+
+=item * WSDL definitions
+
+=item * SOAP messages
+
+=back
+
+=head1 Parser implementations
+
+There are different parser implementations available for SOAP messages - 
+currently there's only one for WSDL definitions.
+
+=head2 WSDL definitions parser
+
+=over
+
+=item * SOAP::WSDL::SAX::WSDLHandler
+
+This is a SAX handler for parsing WSDL files into object trees SOAP::WSDL 
+works with.
+
+It's built as a native handler for XML::LibXML, but will also work with 
+XML::SAX::ParserFactory.
+
+To parse a WSDL file, use one of the following variants:
+
+ my $parser = XML::LibXML->new();
+ my $handler = SOAP::WSDL::SAX::WSDLHandler->new();
+ $parser->set_handler( $handler );
+ $parser->parse( $xml );
+ my $data = $handler->get_data();
+ 
+ 
+ my $handler = SOAP::WSDL::SAX::WSDLHandler->new({
+        base => 'XML::SAX::Base'
+ });
+ my $parser = XML::SAX::ParserFactor->parser(
+    Handler => $handler
+ );
+ $parser->parse( $xml );
+ my $data = $handler->get_data();
+
+=back
+
+=head2 SOAP messages parser
+
+All SOAP message handler use class resolvers for finding out which class 
+a particular XML element should be of and type libs containing these classes.
+
+=head3 Writing a class resolver
+
+The class resolver must returned a method "get_class", which is passed a list
+ref of the current element's XPath (relative to Body), split by /.
+
+This method must return a class name appropriate for a XML element.
+
+A class resolver package might look like this:
+
+ package FakeResolver;
+
+ my %class_list = (
+    'EnqueueMessage' => 'Typelib::TEnqueueMessage',
+    'EnqueueMessage/MMessage' => 'Typelib::TMessage',
+    'EnqueueMessage/MMessage/MRecipientURI' => 'SOAP::WSDL::XSD::Builtin::anyURI',
+    'EnqueueMessage/MMessage/MMessageContent' => 'SOAP::WSDL::XSD::Builtin::string',
+ );
+
+ sub new { return bless {}, 'FakeResolver' };
+
+ sub get_class {
+    my $name = join('/', @{ $_[1] });
+    return ($class_list{ $name }) ? $class_list{ $name }
+        : warn "no class found for $name";
+ };
+ 1;
+
+=head3 Writing type library classes
+
+Every element must have a correspondent one in the type library.
+
+Type library classes must provide the following methods:
+
+Builtin types should be resolved as SOAP::WSDL::XSD::Builtin::* classes
+
+=over
+
+=item * new
+
+Constructor
+
+=item * add_FOO
+
+The add_FOO method is called for every child element of the XML node.
+
+Characters are regarded as child element of the last XML node.
+
+=back
+
+A tyelib class implemented as Inside-Out object using Class::Std::Storable
+as base class would look like this:
+
+    package Typelib::TEnqueueMessage;
+    use strict;
+    use Class::Std::Storable;
+
+    my %MMessage_of :ATTR(:name<MMessage> :default<()>);
+
+    sub add_MMessage {
+           my ($self, $value) = @_;
+           my $ident = ident $self;
+
+           # we're the first value
+           return $MMessage_of{ $ident } = $value
+                if not defined $MMessage_of{ $ident };
+
+           # we're the second value
+           return $MMessage_of{ $ident } = [
+                $MMessage_of{ $ident }, $value ]
+                    if not ref $MMessage_of{ $ident } eq 'ARRAY';
+
+           # we're third or later
+           push @{ $MMessage_of{ $ident } }, $value;
+           return $MMessage_of{ $ident };
+       }
+    }
+    1;
+
+Of course one could use a method factory for these add_FOO methods - see
+t/lib/Typelib/Base.pm for an example.
+
+=head3 Parser implementations
+
+=over
+
+=item * SOAP::WSDL::SAX::MessageHandler
+
+This is a SAX handler for parsing WSDL files into object trees SOAP::WSDL 
+works with.
+
+It's built as a native handler for XML::LibXML, but will also work with 
+XML::SAX::ParserFactory.
+
+Can be used for parsing both streams (chunks) and documents. 
+
+See L<SOAP::WSDL::SAX::MessageHandler> for details.
+
+=item * SOAP::WSDL::Expat::MessageParser
+
+A L<XML::Parser::Expat|XML::Parser::Expat> based parser. This is the fastest 
+parser for most SOAP messages and the default for SOAP::WSDL::Client.
+
+=item * SOAP::WSDL::Expat::MessageStreamParser
+
+A XML::Parser::ExpatNB based parser. Useful for parsing huge HTTP responses, 
+as you don't need to keep everything in memory.
+
+See L<SOAP::WSDL::Expat::MessageStreamParser|SOAP::WSDL::Expat::MessageStreamParser> for details.
+
+=back
+
+=head3 Performance
+
+SOAP::WSDL::Expat::MessageParser is the fastest way of parsing SOAP messages 
+into object trees and only slightly slower than converting them into hash 
+data structures:
+
+ Parsing a SOAP message with a length of 5962 bytes:
+ SOAP::WSDL::Expat::MessageParser:
+    3 wallclock secs ( 3.28 usr +  0.05 sys =  3.33 CPU) @ 60.08/s (n=200)
+  
+ SOAP::WSDL::SAX::MessageHandler (with raw XML::LibXML):   
+   5 wallclock secs ( 4.95 usr +  0.00 sys =  4.95 CPU) @ 40.38/s (n=200)
+ 
+ XML::Simple (XML::Parser):
+   3 wallclock secs ( 2.36 usr +  0.03 sys =  2.39 CPU) @ 83.65/s (n=200)
+ 
+ XML::Simple (XML::SAX::Expat):
+   7 wallclock secs ( 6.50 usr +  0.03 sys =  6.53 CPU) @ 30.62/s (n=200)
+
+As the benchmark shows, all SOAP::WSDL parser variants are faster than 
+XML::Simple with XML::SAX::Expat, and SOAP::WSDL::Expat::MessageParser almost 
+reaches the performance of XML::Simple with XML::Parser as backend.
+
+Parsing SOAP responses in chunks does not increase speed - at least not up 
+to a response size of around 500k:
+
+ Benchmark: timing 5 iterations of SOAP::WSDL::SAX::MessageHandler, 
+   SOAP::WSDL::Expat::MessageParser, SOAP::WSDL::Expat::MessageStreamParser...
+ 
+ SOAP::WSDL::Expat::MessageStreamParser: 
+ 13 wallclock secs ( 7.39 usr +  0.09 sys =  7.48 CPU) @  0.67/s (n=5)
+
+ SOAP::WSDL::Expat::MessageParser: 
+ 10 wallclock secs ( 5.81 usr +  0.06 sys =  5.88 CPU) @  0.85/s (n=5)
+ 
+ SOAP::WSDL::SAX::MessageHandler: 
+ 14 wallclock secs ( 8.78 usr +  0.03 sys =  8.81 CPU) @  0.57/s (n=5)
+ 
+ Response size: 344330 bytes
+
+=cut
--- a/lib/SOAP/WSDL/Part.pm
+++ b/lib/SOAP/WSDL/Part.pm
@@ -0,0 +1,89 @@
+package SOAP::WSDL::Part;
+use strict;
+use warnings;
+use Carp qw(croak);
+use Class::Std::Storable;
+
+use base qw(SOAP::WSDL::Base);
+
+my %element_of  :ATTR(:name<element>    :default<()>);
+my %type_of     :ATTR(:name<type>       :default<()>);
+
+sub serialize
+{
+    my $self = shift;
+    my $name = shift;
+    my $data = shift;
+    my $opt = shift;
+    my $typelib = $opt->{ typelib } || die "No typelib";
+    my %ns_map = reverse %{ $opt->{ namespace } };
+
+    my $item_name;
+    if ($item_name = $self->get_type() ) {
+        # resolve type
+        my ($prefix, $localname) = split /:/ , $item_name, 2;
+        my $type = $typelib->find_type( $ns_map{ $prefix }, $localname	)
+          or die "type $item_name , $ns_map{ $prefix } not found";
+          
+        my $name = $self->get_name();
+	   return $type->serialize( $name, $data->{ $name }, $opt );
+    }
+    elsif ( $item_name = $self->get_element() ) {
+        my ($prefix, $localname) = split /:/ , $item_name, 2;
+        my $element = $typelib->find_element(
+            $ns_map{ $prefix },
+            $localname
+        )
+            or die "element $item_name , $ns_map{ $prefix } not found";
+        $opt->{ qualify } = 1;
+        return $element->serialize( undef, $data->{ $element->get_name() }, $opt );
+    }
+    die "Neither type nor element - don't know what to do";
+}
+
+sub explain {
+    my ($self, $opt, $name ) = @_;
+    my $typelib = $opt->{ wsdl }->first_types() || die "No typelib";
+    my $element = $self->get_type() || $self->get_element();
+
+    # resolve type
+    my $type = $typelib->find_type( $opt->{ wsdl }->_expand( $element ) )
+        || $typelib->find_element( $opt->{ wsdl }->_expand( $element ) );
+
+    if (not $type)
+    {
+        warn "no type/element $element found for part " . $self->get_name();
+        return q{};
+    }
+    return " {\n" .  $type->explain( $opt, $self->get_name() ) . " }\n";
+}
+
+sub to_typemap {
+    my ($self, $opt, $name ) = @_;
+    my $txt = q{};
+    my $wsdl = $opt->{ wsdl };
+    my $typelib = $opt->{ wsdl }->first_types()
+        || die "No typelib";
+
+    # resolve type
+    my $type;
+    if (my $type_name = $self->get_type()) {
+        $type = $typelib->find_type( $wsdl->_expand( $type_name ) )
+            || croak "no type/element $type_name found for part " . $self->get_name();
+        $txt .= "q{} => " . $type->get_name() . "\n";
+    }
+    elsif ( my $element_name = $self->get_element() ) {         
+        $type = $typelib->find_element( $wsdl->_expand( $element_name ) )
+          || croak "no type/element $element_name found for part " . $self->get_name();
+    }
+    else {
+        warn 'neither type nor element - do not know what to do for part ' 
+          . $self->get_name();
+        return q{};
+    }
+    $opt->{ path } = [];
+    $txt .= $type->to_typemap( $opt, $self->get_name() );
+    return $txt;
+}
+
+1;
--- a/lib/SOAP/WSDL/Port.pm
+++ b/lib/SOAP/WSDL/Port.pm
@@ -0,0 +1,43 @@
+package SOAP::WSDL::Port;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %binding_of :ATTR(:name<binding> :default<()>);
+my %location_of :ATTR(:name<location> :default<()>);
+
+sub explain {
+
+    my $self = shift;
+    my $opt = shift;
+    $opt->{ wsdl } || die 'required attribute wsdl missing'; 
+
+    my $binding = $opt->{ wsdl }->find_binding(
+        $opt->{ wsdl }->_expand( $self->get_binding() )
+    ) or die 'binding ' . $self->get_binding()  . ' not found !';
+
+
+    my $txt = "=head2 Service information:\n\n"
+        . " Port name: " . $self->get_name() . "\n"
+        . " Binding: " . $self->get_binding() ."\n"
+        . " Location: " . $self->get_location() ."\n"
+        . $binding->explain($opt);
+
+    return $txt;
+}
+
+sub to_typemap {
+
+    my $self = shift;
+    my $opt = shift;
+    my %ns_map = reverse %{ $opt->{ wsdl }->get_xmlns() };
+
+    my ($prefix, $localname) = split /:/ , $self->get_binding();
+    my $binding = $opt->{ wsdl }->find_binding(
+            $ns_map{ $prefix }, $localname
+    ) or die "binding $prefix:$localname not found !";
+
+    return $binding->to_typemap($opt);
+}
+1;
--- a/lib/SOAP/WSDL/PortType.pm
+++ b/lib/SOAP/WSDL/PortType.pm
@@ -0,0 +1,32 @@
+package SOAP::WSDL::PortType;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %operation_of :ATTR(:name<operation> :default<()>);
+
+my %attributes_of :ATTR();
+
+%attributes_of = (
+    operation => \%operation_of,
+);
+
+# Function factory - we could be writing this method for all %attribute
+# keys, too, but that's just C&P (eehm, Copy & Paste...)
+foreach my $method(keys %attributes_of ) {
+    no strict qw/refs/;
+
+    # ... btw, we mean this method here...
+    *{ "find_$method" } = sub {
+        my ($self, @args) = @_;
+        my @found_at = grep {
+            $_->get_targetNamespace() eq $args[0] &&
+            $_->get_name() eq $args[1]
+        }
+        @{ $attributes_of{ $method }->{ ident $self } };
+        return $found_at[0];
+    };
+}
+
+1;
--- a/lib/SOAP/WSDL/SAX/MessageHandler.pm
+++ b/lib/SOAP/WSDL/SAX/MessageHandler.pm
@@ -0,0 +1,281 @@
+#!/usr/bin/perl
+package SOAP::WSDL::SAX::MessageHandler;
+use strict;
+use warnings;
+use Scalar::Util qw(blessed);
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+
+my %characters_of :ATTR(:default<()>);
+my %class_resolver_of :ATTR(:default<()> :name<class_resolver>);
+my %current_of :ATTR(:default<()>);
+my %ignore_of :ATTR(:default<()>);
+my %list_of :ATTR(:default<()>);
+my %namespace_of :ATTR(:default<()>);
+my %path_of :ATTR(:default<()>);
+my %data_of :ATTR(:default<()>);
+
+{
+    # we have to implement our own new - we need a blessed Hash ref as $self
+    # for being able to inherit from XML::SAX::Base...
+    no warnings qw(redefine);
+    sub new {
+        my $class = shift;
+        my $self = {}; # $class->SUPER::new(@_);
+        my $args = shift || {};
+
+        die "arguments to new must be single hash ref"
+            if @_ or ! ref $args eq 'HASH';
+
+        # nasty, but for those who want to use XML::SAX::Base or similar
+        # as parser factory
+        if ($args->{base}) {
+            # yup, naughty string eval
+            eval "use base qw($args->{base})";  ## no critic qw(ProhibitStringyEval)
+        }
+        else {
+            # create all those SAX methods...
+            # ...we ignore em all...
+            no strict qw(refs);
+            foreach my $method ( qw(
+                 processing_instruction
+                 ignorable_whitespace
+                 set_document_locator
+                 start_prefix_mapping
+                 end_prefix_mapping
+                 skipped_entity
+                 start_cdata
+                 end_cdata
+                 comment
+                 entity_reference
+                 notation_decl
+                 unparsed_entity_decl
+                 element_decl
+                 attlist_decl
+                 doctype_decl
+                 xml_decl
+                 entity_decl
+                 attribute_decl
+                 internal_entity_decl
+                 external_entity_decl
+                 resolve_entity
+                 start_dtd
+                 end_dtd
+                 start_entity
+                 end_entity
+                 warning
+            ) ) {
+                *{ "$method" } = sub {};
+            }
+        }
+
+        $class_resolver_of{ ident $self } = $args->{ class_resolver }
+            if $args->{ class_resolver };
+
+        return bless $self, $class;
+    }
+}
+
+sub class_resolver {
+    my $self = shift;
+    $class_resolver_of{ ident $self } = shift;
+}
+
+sub start_document {
+    my $ident = ident $_[0];
+    $list_of{ $ident } = [];
+    $current_of{ $ident } = '__STOP__';             # use as marker
+    $namespace_of{ $ident } = {};
+    $ignore_of{ $ident } = [ qw(Envelope Body) ];   # SOAP elements
+    $path_of{ $ident } = [];
+    $data_of{ $ident } = undef;   
+}
+
+sub start_element {
+    # use $_[n] for performance
+    my ($ident, $element) = (ident $_[0], $_[1]);
+
+    # ignore top level elements
+    if (@{ $ignore_of{ $ident } }
+        && $element->{ LocalName } eq $ignore_of{ $ident }->[0]) {
+        shift @{ $ignore_of{ $ident } };
+        return;
+    }
+
+    # empty characters
+    $characters_of{ $ident } = q{};
+
+    push @{ $path_of{ $ident } }, $element->{ LocalName };  # step down...
+    push @{ $list_of{ $ident } }, $current_of{ $ident };    # remember current
+
+    # resolve class of this element
+    my $class = $class_resolver_of{ $ident }->get_class( $path_of{ $ident } )
+        or die "Cannot resolve class for "
+            . join('/', @{ $path_of{ $ident } })
+            . " via "
+            . $class_resolver_of{ $ident };
+
+    # Check whether we have a primitive - we implement them as classes
+    # TODO replace with UNIVERSAL->isa()
+    # match is a bit faster if the string does not match, but WAY slower 
+    # if $class matches...
+    # if (not $class=~m{^SOAP::WSDL::XSD::Typelib::Builtin}xms) {      
+    if (index $class, 'SOAP::WSDL::XSD::Typelib::Builtin', 0 < 0) {
+
+        # check wheter there is a CODE reference for $class::new.
+        # If not, require it - all classes required here MUST
+        # define new()
+        # This is the same as $class->can('new'), but it's way faster  
+        no strict qw(refs);
+        *{ "$class\::new" }{ CODE } 
+            or eval "require $class"   ## no critic qw(ProhibitStringyEval)
+                or die $@;
+    }
+    # create object
+    # set current object
+    $current_of{ $ident } = $class->new({
+        map { $_->{ Name } => $_->{ Value } }
+            values %{ $element->{ Attributes } }
+    });
+
+    # remember top level element
+    defined $data_of{ $ident } 
+        or ($data_of{ $ident } = $current_of{ $ident }); 
+}
+
+sub characters {
+    $characters_of{ ident $_[0] } .= $_[1]->{ Data };
+}
+
+sub end_element {
+    # $_[n] used for performance
+    my ($ident, $element) = (ident $_[0], $_[1]);
+  
+    # This one easily handles ignores for us, too...
+    return if not ref $list_of{ $ident }->[-1];
+
+    if ( $current_of{ $ident }
+        ->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType') ) {
+        $current_of{ $ident }->set_value( $characters_of{ $ident } );
+    }
+
+    # set appropriate attribute in last element
+    # multiple values must be implemented in base class
+    my $method = "add_$element->{ LocalName }";
+
+    $list_of{ $ident }->[-1]->$method( $current_of{ $ident } );
+
+    # step up in path
+    pop @{ $path_of{ $ident } };
+    
+    # step up in object hierarchy...
+    $current_of{ $ident } = pop @{ $list_of{ $ident } };
+}
+
+sub end_document {
+    my $self = shift;
+    my $ident = ident $self;
+
+    # destroy all remains except data_of
+    $list_of{ $ident } = ();
+    $namespace_of{ $ident } = ();
+    $ignore_of{ $ident } = ();
+    $path_of{ $ident } = ();
+    $characters_of{ $ident } = ();
+}
+
+sub get_data {
+    my $self = shift;
+    return $data_of{ ident $self };
+}
+
+sub fatal_error {
+    my $self = shift;
+    die "Fatal error parsing document: " , @_;
+}
+
+sub error {
+    my $self = shift;
+    die "Error parsing document: " , @_;
+}
+
+
+1;
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::SAX::MessageHandler - Convert SOAP messages to custom object trees
+
+=head1 SYNOPSIS
+
+ # this is the direct variant, recommended for performance
+ use SOAP::WSDL::SAX::MessageHandler;
+ use XML::LibXML;
+
+ my $filter = SOAP::WSDL::SAX::MessageHandler->new( {
+    class_resolver => FakeResolver->new()
+ ), "Object creation");
+ my $parser = XML::LibXML->new();
+ $parser->set_handler( $filter );
+
+ $parser->parse_string( $soap_message );
+
+ my $object_tree = $filter->get_data();
+
+
+ # This is the XML::ParserFactory variant - for those who want other
+ # parsers than XML::Simple....
+ use SOAP::WSDL::SAX::MessageHandler;
+ use XML::SAX::ParserFactory;
+
+ my $filter = SOAP::WSDL::SAX::MessageHandler->new( {
+    class_resolver => FakeResolver->new(),
+    base => 'XML::SAX::Base',
+ ), "Object creation");
+ my $parser = XML::SAX::ParserFactor->parser(
+    Handler => $handler
+ );
+ $parser->parse_string( $soap_message );
+
+ my $object_tree = $filter->get_data();
+
+=head1 DESCRIPTION
+
+SAX handler for parsing SOAP messages.
+
+See L<SOAP::WSDL::Parser> for details.
+
+=head1 Bugs and Limitations
+
+=over
+
+=item * Ignores all namespaces
+
+=item * Does not handle mixed content
+
+=item * The SOAP header is ignored
+
+=back
+
+=head1 AUTHOR
+
+Replace the whitespace by @ for E-Mail Address.
+
+ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=head1 COPYING
+
+This module may be used under the same terms as perl itself.
+
+=head1 Repository information
+
+ $ID: $
+
+ $LastChangedDate: $
+ $LastChangedRevision: $
+ $LastChangedBy: $
+
+ $HeadURL: $
+
--- a/lib/SOAP/WSDL/SAX/WSDLHandler.pm
+++ b/lib/SOAP/WSDL/SAX/WSDLHandler.pm
@@ -0,0 +1,161 @@
+package SOAP::WSDL::SAX::WSDLHandler;
+use strict;
+use warnings;
+use Carp;
+use Class::Std::Storable;
+# use base qw(XML::SAX::Base);
+use SOAP::WSDL::TypeLookup;
+
+my %tree_of :ATTR(:name<tree> :default<{}>);
+my %order_of :ATTR(:name<order> :default<[]>);
+my %targetNamespace_of :ATTR(:name<targetNamespace> :default<()>);
+my %current_of :ATTR(:name<current> :default<()>);
+
+{
+    # we have to implement our own new - we need a blessed Hash ref as $self
+    # for being able to inherit from XML::SAX::Base...
+    no warnings qw(redefine);
+    sub new {
+        my $class = shift;
+        my $self = {}; # $class->SUPER::new(@_);
+        my $args = shift || {};
+    
+        die "arguments to new must be single hash ref"
+            if @_ or ! ref $args eq 'HASH';
+    
+        # nasty, but for those who want to use XML::SAX::Base or similar
+        # as parser factory
+        if ($args->{base}) {
+            # yup, naughty string eval
+            eval "use base qw($args->{base})";  ## no critic qw(ProhibitStringyEval)
+        }
+        else {
+            # create all those SAX methods...
+            # ...we ignore em all...
+            no strict qw(refs);
+            foreach my $method ( qw(
+                characters
+                processing_instruction
+                ignorable_whitespace
+                set_document_locator
+                start_prefix_mapping
+                end_prefix_mapping
+                skipped_entity
+                start_cdata
+                end_cdata
+                comment
+                entity_reference
+                notation_decl
+                unparsed_entity_decl
+                element_decl
+                attlist_decl
+                doctype_decl
+                xml_decl
+                entity_decl
+                attribute_decl
+                internal_entity_decl
+                external_entity_decl
+                resolve_entity
+                start_dtd
+                end_dtd
+                start_entity
+                end_entity
+                warning
+                error
+            ) ) {
+                *{ "$method" } = sub {};
+            }
+        }
+
+        return bless $self, $class;
+    }
+};
+
+sub start_document {
+    my $ident = ident $_[0];
+    $tree_of{ $ident } = {};
+    $order_of{ $ident } = [];
+    $targetNamespace_of{ $ident } = undef;
+    $current_of{ $ident } = undef;
+}
+
+sub start_element {
+    my ($self, $element) = @_;
+    my $ident = ident $self;
+
+    my $action = SOAP::WSDL::TypeLookup->lookup(
+        $element->{ NamespaceURI },
+        $element->{ LocalName }
+    );
+
+    return if not $action;
+    
+    if ($action->{ type } eq 'CLASS') {
+        eval "require $action->{ class }";
+        croak $@, $tree_of{ $ident } if ($@);
+
+        my $class = $action->{ class };
+        my $obj = $class->new({ parent => $current_of{ $ident } })->init(
+            values %{ $element->{ Attributes } }
+        );
+
+        # set element in parent
+        if ($current_of{ $ident }) {
+            # inherit namespace, but don't override
+            $obj->set_targetNamespace(
+                $current_of{ $ident }->get_targetNamespace() )
+                    if not $obj->get_targetNamespace();
+
+            # push on name list
+            my $method = "push_$element->{ LocalName }";
+            no strict qw(refs);
+            $current_of{ $ident }->$method( $obj );
+
+            # remember element for stepping back
+            push @{ $order_of{ $ident } }, $current_of{ $ident };
+        }
+        else {
+            $tree_of{ $ident } = $obj;
+        }
+        # set new element (step down)
+        $current_of{ $ident } = $obj;
+    }
+    elsif ($action->{ type } eq 'PARENT') {
+        $current_of{ $ident }->init( values %{ $element->{ Attributes } }	);
+    }
+    elsif ($action->{ type } eq 'METHOD') {
+        my $method = $action->{ method } || $element->{ LocalName };
+
+        no strict qw(refs);
+        # call method with
+        # - default value ($action->{ value } if defined,
+        #   dereferencing lists
+        # - the values of the elements Attributes hash
+        $current_of{ $ident }->$method( defined $action->{ value }
+            ? ref $action->{ value }
+                ? @{ $action->{ value } }
+                : ($action->{ value })
+            : values %{ $element->{ Attributes } } );
+    }
+}
+
+sub end_element {
+	my ($self, $element) = @_;
+    my $ident = ident $self;
+
+	my $action = SOAP::WSDL::TypeLookup->lookup(
+		$element->{ NamespaceURI },
+		$element->{ LocalName }
+	) || {};
+
+	if ($action->{ type } &&  $action->{ type } eq 'CLASS' )
+	{
+		$current_of{ $ident } = pop @{ $order_of{ $ident } };
+	}
+}
+
+sub get_data {
+	my $self = shift;
+	return $tree_of{ ident $self };
+}
+1;
--- a/lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
+++ b/lib/SOAP/WSDL/SOAP/Typelib/Fault11.pm
@@ -0,0 +1,100 @@
+package SOAP::WSDL::SOAP::Typelib::Fault11;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use Data::Dumper;
+
+use SOAP::WSDL::XSD::Typelib::ComplexType;
+use SOAP::WSDL::XSD::Typelib::Element;
+
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Element
+    SOAP::WSDL::XSD::Typelib::ComplexType
+);
+
+my %faultcode_of :ATTR(:get<faultcode>);
+my %faultstring_of :ATTR(:get<faultstring>);
+my %faultactor_of :ATTR(:get<faultactor>);
+my %detail_of :ATTR(:get<detail>);
+
+# always return false in boolean context - a fault is never true...
+sub as_bool :BOOLIFY { return; }
+
+__PACKAGE__->_factory(
+    [ qw(faultcode faultstring faultactor detail) ],
+    {
+        faultcode => \%faultcode_of,
+        faultstring => \%faultstring_of,
+        faultactor => \%faultactor_of,
+        detail => \%detail_of,          
+    },
+    {
+        faultcode => 'SOAP::WSDL::XSD::Typelib::Builtin::QName',
+        faultstring => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+        faultactor => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI',
+        detail => 'SOAP::WSDL::XSD::Typelib::Builtin::anyType',            
+    }
+);
+
+sub get_xmlns { return 'http://schemas.xmlsoap.org/soap/envelope/' };
+
+__PACKAGE__->__set_name('Fault');
+__PACKAGE__->__set_nillable();
+__PACKAGE__->__set_minOccurs();
+__PACKAGE__->__set_maxOccurs();
+__PACKAGE__->__set_ref('');
+
+1;
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::SOAP::Typelib::Fault11 - SOAP 1.1 Fault class
+
+=head1 DESCRIPTION
+
+Models a SOAP 1.1 Fault.
+
+SOAP::WSDL::SOAP::Typelib::Fault11 objects are false in boolean context 
+and serialize to XML on stringification.
+
+This means you can do something like:
+
+ my $soap = SOAP::WSDL::Client->new();
+ # ...
+ my $result = $soap->call($method, $data);
+ if (not $result) {
+     die "Error calling SOAP method: ", $result->get_faultstring();
+ }
+
+=head1 METHODS
+
+=head2 get_faultcode / set_faultcode
+
+Getter/setter for object's the faultcode property.
+
+=head2 get_faultstring / set_faultstring
+
+Getter/setter for object's the faultstring property.
+
+=head2 get_faultactor / set_faultactor
+
+Getter/setter for object's the faultactor property.
+
+=head2 get_detail / set_detail
+
+Getter/setter for detail object's detail property.
+
+=head1 LICENSE
+
+Copyright 2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/Service.pm
+++ b/lib/SOAP/WSDL/Service.pm
@@ -0,0 +1,32 @@
+package SOAP::WSDL::Service;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %port_of    :ATTR(:name<port>   :default<()>);
+
+sub explain {
+	my $self = shift;
+	my $opt = shift;
+	my $txt ="=head1 Service " . $self->get_name() . "\n\n";
+	foreach my $port (@{ $self->get_port() } )
+	{
+		$txt .= $port->explain( $opt );
+	}
+	return $txt;
+}
+
+sub to_typemap {
+    my $self = shift;
+    my $opt = shift;
+    return  join "\n",
+        map { $_->to_typemap( $opt ) } @{ $port_of{ ident $self } };
+}
+
+# TODO implement to_class as class generator for a (complete) interface
+sub to_class {
+}
+
+
+1;
--- a/lib/SOAP/WSDL/SoapOperation.pm
+++ b/lib/SOAP/WSDL/SoapOperation.pm
@@ -0,0 +1,23 @@
+package SOAP::WSDL::SoapOperation;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %input_of :ATTR(:name<input> :default<()>);
+my %output_of :ATTR(:name<output> :default<()>);
+my %fault_of :ATTR(:name<fault> :default<()>);
+my %style_of :ATTR(:name<style> :default<()>);
+my %soapAction_of :ATTR(:name<soapAction> :default<()>);
+
+sub explain {
+	my $self = shift;
+	my $opt = shift;
+	my $txt = '';
+	$opt->{ indent } ||= '';
+
+	$txt .= $opt->{ indent } . "soapAction: " . $self->soapAction() . "\n"
+		if ( $self->soapAction() );
+
+	return $txt;
+}
+
+1;
--- a/lib/SOAP/WSDL/TypeLookup.pm
+++ b/lib/SOAP/WSDL/TypeLookup.pm
@@ -0,0 +1,152 @@
+package SOAP::WSDL::TypeLookup;
+
+my %TYPES = (
+	# wsdl:
+	'http://schemas.xmlsoap.org/wsdl/' => {
+		binding => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Binding',
+		},
+		definitions => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Definitions',
+		},
+		portType => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::PortType',
+		},
+		types => {
+			type => 'SKIP',
+		},
+		message => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Message',
+		},
+		part => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Part',
+		},
+		service => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Service',
+		},
+		port => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Port',
+		},
+		operation => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Operation',
+		},
+		input => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::OpMessage',
+		},
+		output => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::OpMessage',
+		},
+		fault => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::OpMessage',
+		},
+		types => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::Types',
+		}
+	},
+	# soap:
+	'http://schemas.xmlsoap.org/wsdl/soap/' => {
+		operation => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::SoapOperation',
+		},
+		binding => {
+			type => 'PARENT',
+		},
+		body => {
+			type => 'PARENT',
+		},
+		address => {
+			type => 'PARENT',
+		}
+	},
+	'http://www.w3c.org/2001/XMLSchema' => {
+		schema => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::XSD::Schema',
+		},
+		element => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::XSD::Element',
+		},
+		simpleType => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::XSD::SimpleType',
+		},
+		complexType => {
+			type => 'CLASS',
+			class => 'SOAP::WSDL::XSD::ComplexType',
+		},
+        simpleContent => {
+            type => 'METHOD',
+            method => 'set_contentModel',
+            value => 'simpleContent'
+        },
+        complexContent => {
+            type => 'METHOD',
+            method => 'set_contentModel',
+            value => 'complexContent'
+        },
+		restriction => {
+			type => 'METHOD',
+			method => 'set_restriction',
+		},
+		list => {
+			type => 'METHOD',
+			method => 'set_list',
+		},
+		union => {
+			type => 'METHOD',
+			method => 'set_union',
+		},
+		enumeration => {
+			type => 'METHOD',
+			method => 'push_enumeration',
+		},
+        group => {
+            type => 'METHOD',
+            method => 'set_flavor',
+            value => 'all',
+        },
+		all => {
+			type => 'METHOD',
+			method => 'set_flavor',
+            value => 'all',
+		},
+        choice => {
+            type => 'METHOD',
+            method => 'set_flavor',
+            value => 'choice',
+        },
+        sequence => {
+            type => 'METHOD',
+            method => 'set_flavor',
+            value => 'sequence',
+        },
+
+	},
+);
+
+# thei're equal (typo ?)
+$TYPES{	'http://www.w3.org/2001/XMLSchema' } = $TYPES{
+		'http://www.w3c.org/2001/XMLSchema'
+};
+
+
+sub lookup {
+	my $self = shift;
+	my $namespace = shift || 'http://schemas.xmlsoap.org/wsdl/';
+	my $name = shift;
+	return $TYPES{ $namespace }->{ $name };
+}
--- a/lib/SOAP/WSDL/Types.pm
+++ b/lib/SOAP/WSDL/Types.pm
@@ -0,0 +1,37 @@
+package SOAP::WSDL::Types;
+use strict;
+use warnings;
+use SOAP::WSDL::XSD::Schema::Builtin;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+
+my %schema_of :ATTR(:name<schema> :default<[]>);
+
+sub START {
+    my ($self, $ident, $args_of) = @_;
+    $self->push_schema( SOAP::WSDL::XSD::Schema::Builtin->new() );
+    return $self;
+}
+
+sub find_type {
+    my ($self, $ns, $name) = @_;
+
+    foreach my $schema (@{ $schema_of{ ident $self } }) {
+        my $type = $schema->find_type($ns, $name);
+        return $type if $type;
+    }
+    return;
+}
+
+sub find_element {
+    my ($self, $ns, $name) = @_;
+
+    foreach my $schema (@{ $schema_of{ ident $self } }) {
+        my $type = $schema->find_element($ns, $name);
+        return $type if $type;
+    }
+    return;
+}
+
+1;
--- a/lib/SOAP/WSDL/XSD/ComplexType.pm
+++ b/lib/SOAP/WSDL/XSD/ComplexType.pm
@@ -0,0 +1,325 @@
+package SOAP::WSDL::XSD::ComplexType;
+use strict;
+use warnings;
+use Carp;
+use Class::Std::Storable;
+use Scalar::Util qw(blessed);
+use base qw/SOAP::WSDL::Base/;
+use Data::Dumper;
+
+my %annotation_of   :ATTR(:name<annotation> :default<()>);
+my %element_of      :ATTR(:name<element>    :default<()>);
+my %flavor_of       :ATTR(:name<flavor>     :default<()>);
+my %base_of         :ATTR(:name<base>       :default<()>);
+my %itemType_of     :ATTR(:name<itemType>   :default<()>);
+my %enumeration_of  :ATTR(:name<enumeration>   :default<()>);
+my %abstract_of     :ATTR(:name<abstract>   :default<()>);
+# is set to simpleContent/complexContent
+my %content_Model_of    :ATTR(:name<contentModel>   :default<()>);
+
+sub find_element {
+    my ($self, @args) = @_;
+    my @found_at = grep {
+        $_->get_targetNamespace() eq $args[0] &&
+        $_->get_name() eq $args[1]
+    }
+    @{ $element_of{ ident $self } };
+    return $found_at[0];
+}
+
+sub push_element {
+    my $self = shift;
+    my $element = shift;
+    if ($flavor_of{ ident $self } eq 'all')
+    {
+        $element->set_minOccurs(0) if not defined ($element->get_minOccurs);
+        $element->set_maxOccurs(1) if not defined ($element->get_maxOccurs);
+    }
+    elsif ($flavor_of{ ident $self } eq 'sequence')
+    {
+        $element->set_minOccurs(1) if not defined ($element->get_minOccurs);
+        $element->set_maxOccurs(1) if not defined ($element->get_maxOccurs);
+    }
+    push @{ $element_of{ ident $self } }, $element;
+}
+
+sub set_restriction {
+    my $self = shift;
+    my $element = shift;
+    $flavor_of{ ident $self } = 'restriction';
+    $base_of{ ident $self } = $element->{ Value };
+}
+
+
+sub init {
+	my $self = shift;
+	my @args = @_;
+	$self->SUPER::init( @args );
+}
+
+sub serialize {
+    my ($self, $name, $value, $opt) = @_;
+
+    $opt->{ indent } ||= q{};
+    $opt->{ attributes } ||= [];
+    my $flavor = $self->get_flavor();
+    my $xml = ($opt->{ readable }) ? $opt->{ indent } : q{};    # add indentation
+
+
+    if ( $opt->{ qualify } ) {
+        $opt->{ attributes } = [ ' xmlns="' . $self->get_targetNamespace .'"' ];
+        delete $opt->{ qualify };
+    }      
+
+
+    $xml .= join q{ } , "<$name" , @{ $opt->{ attributes } };
+    delete $opt->{ attributes };                                # don't propagate...
+    
+    if ( $opt->{ autotype }) {
+      my $ns = $self->get_targetNamespace();
+      my $prefix = $opt->{ namespace }->{ $ns }
+        || die 'No prefix found for namespace '. $ns;
+      $xml .= join q{}, " type=\"$prefix:", $self->get_name(), '" '
+        if ($self->get_name() );
+    }
+    $xml .= '>';
+    $xml .= "\n" if ( $opt->{ readable } );				# add linebreak
+    if ( ($flavor eq "sequence") or ($flavor eq "all") )
+    {
+        $opt->{ indent } .= "\t";
+        for my $element (@{ $self->get_element() }) {
+            # might be list - listify
+            $value = [ $value ] if not ref $value eq 'ARRAY';
+
+            for my $single_value (@{ $value }) {
+    		my $element_value;
+	       	if (blessed $single_value) {
+                    my $method = 'get_' . $element->get_name();
+		    $element_value = $single_value->$method();
+                }
+    		else {
+                    $element_value = $single_value->{ $element->get_name() };
+                }
+    		$element_value = [ $element_value ]
+                    if not ref $element_value eq 'ARRAY';
+
+    		$xml .= join q{}
+                  , map { $element->serialize( undef, $_, $opt ) }
+	              @{ $element_value };
+            }
+        }
+      $opt->{ indent } =~s/\t$//;
+    }
+    else {
+      die "sorry, we just handle all and sequence types yet...";
+    }
+    $xml .= $opt->{ indent } if ( $opt->{ readable } ); # add indentation
+    $xml .= '</' . $name . '>';
+    $xml .= "\n" if ($opt->{ readable } );              # add linebreak
+    return $xml;
+}
+
+sub explain {
+    my ($self, $opt, $name ) = @_;
+    my $flavor = $self->get_flavor();
+
+    $name ||= q{};
+
+    return q{}  if not $flavor;          # empty complexType
+    $opt->{ indent } ||= q{   };
+    my $xml = q{};
+    $xml .= "$opt->{indent}\'$name'=> " if $name;
+
+    if ( ($flavor eq "sequence") or ($flavor eq "all") ) {
+        $xml .= "{\n";
+        $opt->{ indent } .= "  ";
+        $xml .= join q{}, map { $_->explain( $opt ) }
+            @{ $self->get_element() };
+        $opt->{ indent } =~s/\s{2}$//;                     # step back
+        $xml .= "$opt->{ indent }},\n";
+    }
+    elsif ($flavor eq "complexContent")
+    {
+
+    }
+    elsif ($flavor eq "simpleContent")
+    {
+        warn "found unsupported complexType definition $flavor";
+    }
+    else
+    {
+        warn "found unsupported complexType definition $flavor";
+    }
+    return $xml;
+}
+
+sub to_typemap {
+    my ($self, $opt, $name ) = @_;
+    my $flavor = $self->get_flavor();
+    my $txt;
+    return q{} if not $flavor;                                                         # empty complexType
+
+    my %nsmap = reverse %{ $opt->{ wsdl }->get_xmlns() };
+
+    if ( ($flavor eq "sequence") or ($flavor eq "all") )
+    {
+        for my $element (@{ $self->get_element() }) {
+            $txt .= $element->to_typemap( $opt );
+        }
+    }
+    return $txt;
+}
+
+sub to_class {
+    my $self = shift;
+    my $opt = shift;
+
+my $template = <<'EOT';
+package [% type_prefix %][% self.get_name %];
+use strict;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::ComplexType;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::ComplexType
+);
+
+[% FOREACH element=self.get_element -%]
+my %[% element.get_name %]_of :ATTR(:get<[% element.get_name %]>);
+[% END %]
+
+__PACKAGE__->_factory(
+    [ qw([% FOREACH element=self.get_element -%] 
+    [% element.get_name %] 
+    [% END %]) ],
+    { 
+      [% FOREACH element=self.get_element %][% element.get_name %] => \%[% element.get_name %]_of, 
+      [% END %]  
+    },
+    {
+[%- 
+      FOREACH element=self.get_element;
+        IF (element.get_type);
+          split_name = element.get_type.split(':');
+          prefix = split_name.0;
+          localname = split_name.1;
+          IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' -%]
+      [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',
+[%        ELSE -%]
+      [% element.get_name %] => '[% type_prefix %][% localname %]',
+[%-       END;
+        ELSIF (simpleType = element.first_simpleType); 
+          base = simpleType.get_base();
+%]
+      # basic simple type handling: we treat atomic simple types 
+      # in complexType elements as their base types
+      # - and we only treat <restriction base="..."> yet.
+      # our base here is [% base %]
+[%
+          split_name = base.split(':');
+          prefix = split_name.0;
+          localname = split_name.1;
+          IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' -%]
+      [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',
+[%        ELSE -%]
+      [% element.get_name %] => '[% type_prefix %][% localname %]',
+[%-       END;
+        END;
+      END %]
+    }
+);
+
+sub get_xmlns { '[% self.get_targetNamespace %]' }
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME [% type_prefix %][% self.get_name %]
+
+=head1 SYNOPSIS
+
+=head1 DESCRIPTION
+
+Type class for the XML type [% self.get_name %]. 
+
+=head1 PROPERTIES
+
+The following properties may be accessed using get_PROPERTY / set_PROPERTY 
+methods:
+
+[%-      FOREACH element = self.get_element %]
+ [% element.get_name -%]
+[%      END %]
+
+=head1 Object structure
+
+[% FOREACH element=self.get_element;
+        IF (element.get_type);
+          split_name = element.get_type.split(':');
+          prefix = split_name.0;
+          localname = split_name.1;
+          IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' -%]
+      [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',
+[%        ELSE -%]
+      [% element.get_name %] => '[% type_prefix %][% localname %]',
+[%-       END;
+        ELSIF (simpleType = element.first_simpleType); 
+          base = simpleType.get_base();
+          split_name = base.split(':');
+          prefix = split_name.0;
+          localname = split_name.1;
+          IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' -%]
+      [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',
+[%        ELSE -%]
+      [% element.get_name %] => '[% type_prefix %][% localname %]',
+[%-       END;
+        END;
+      END %]
+
+Structure as perl hash: 
+
+ The object structure is displayed as hash below though this is not correct.
+ Complex hash elements actually are objects of their corresponding classes 
+ (look for classes of the same name in your typleib).
+ new() will accept a hash structure like this, but transform it to a object 
+ tree.
+
+ [% structure %]
+
+=cut
+
+EOT
+
+    $self->SUPER::to_class($opt, $template);
+}
+
+sub _check_value {
+	my $self = shift;
+}
+1;
+
+=pod
+
+=head1 Bugs and limitations
+
+=over
+
+=item * attribute definitions
+
+Attribute definitions are ignored
+
+=item * abstract, block, final, mixed
+
+Handling of these attribute is not implemented yet.
+
+=item * simpleContent, complexContent, extension, restriction, group, choice
+
+Handling of these child elements is not implemented yet
+
+=item * explain may produce erroneous results
+
+=back
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Element.pm
+++ b/lib/SOAP/WSDL/XSD/Element.pm
@@ -0,0 +1,415 @@
+package SOAP::WSDL::XSD::Element;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+use Data::Dumper;
+
+my %simpleType_of   :ATTR(:name<simpleType>  :default<()>);
+my %complexType_of  :ATTR(:name<complexType> :default<()>);
+my %facet_of        :ATTR(:name<facet>      :default<()>);
+my %type_of         :ATTR(:name<type>       :default<()>);
+my %abstract_of     :ATTR(:name<abstract>   :default<()>);
+my %block_of        :ATTR(:name<block>      :default<()>);
+my %default_of      :ATTR(:name<default>    :default<()>);
+my %final_of        :ATTR(:name<final>      :default<()>);
+my %fixed_of        :ATTR(:name<fixed>      :default<()>);
+my %form_of         :ATTR(:name<form>       :default<()>);
+my %maxOccurs_of    :ATTR(:name<maxOccurs>  :default<()>);
+my %minOccurs_of    :ATTR(:name<minOccurs>  :default<()>);
+my %nillable_of     :ATTR(:name<nillable>   :default<()>);
+my %ref_of          :ATTR(:name<ref>        :default<()>);
+my %substitutionGroup_of :ATTR(:name<substitutionGroup> :default<()>);
+
+sub first_type {
+    my $result_ref = $complexType_of{ ident shift };
+    return if not $result_ref;
+    return $result_ref if (not ref $result_ref eq 'ARRAY');
+    return $result_ref->[0];
+}
+
+sub first_simpleType {
+    my $result_ref = $simpleType_of{ ident shift };
+    return if not $result_ref;
+    return $result_ref if (not ref $result_ref eq 'ARRAY');
+    return $result_ref->[0];
+}
+
+sub first_complexType {
+    my $result_ref = $complexType_of{ ident shift };
+    return if not $result_ref;
+    return $result_ref if (not ref $result_ref eq 'ARRAY');
+    return $result_ref->[0];
+}
+
+# serialize type instead...
+sub serialize {
+    my ($self, $name, $value, $opt) = @_;
+    my $type;
+    my $typelib = $opt->{ typelib };
+    my %ns_map = reverse %{ $opt->{ namespace } };
+    my $ident = ident $self;
+
+    # abstract elements may only be serialized via ref - and then we have a
+    # name...
+    die "cannot serialize abstract element" if $abstract_of{ $ident }
+        and not $name;
+
+    # TODO: implement final and substitutionGroup - maybe never implement
+    # substitutionGroup ?
+
+    $name ||= $self->get_name();
+
+    if ( $opt->{ qualify } ) {
+        $opt->{ attributes } = [ ' xmlns="' . $self->get_targetNamespace .'"' ];
+    }      
+
+
+    # set default and fixed - fixed overrides everything,
+    # default only empty (undefined) values
+    if (not defined $value)     {
+      $value = $default_of{ ident $self } if $default_of{ ident $self };
+    }
+    $value = $fixed_of{ ident $self } if $fixed_of{ ident $self };
+
+    # TODO check nillable and serialize empty data correctly
+
+    # return if minOccurs is 0 and we have no value
+    if (defined $minOccurs_of{ ident $self }
+        and $minOccurs_of{ ident $self } == 0) {
+        return q{} if not defined $value;
+    }
+
+    # handle direct simpleType and complexType here
+    if ($type = $self->first_simpleType() ) {             # simpleType
+        return $type->serialize( $name, $value, $opt );
+    }
+    elsif ($type = $self->first_complexType() ) {           # complexType
+        return $type->serialize( $name, $value, $opt );
+    }
+    elsif (my $ref_name = $ref_of{ $ident }) {              # ref
+        my ($prefix, $localname) = split /:/ , $ref_name;
+        my $ns = $ns_map{ $prefix };
+        $type = $typelib->find_type( $ns, $localname );
+        die "no type for $prefix:$localname" if (not $type);
+        return $type->serialize( $name, $value, $opt );
+    }
+
+    # lookup type
+    my ($prefix, $localname) = split /:/ , $self->get_type();
+    my $ns = $ns_map{ $prefix };
+	$type = $typelib->find_type(
+		$ns, $localname
+	);
+
+    # safety check
+    die "no type for $prefix:$localname $ns_map{$prefix}" if (not $type);
+
+    return $type->serialize( $name, $value, $opt );
+}
+
+sub explain {
+	my ($self, $opt, $name) = @_;
+	my $type;
+    my $text = q{};
+
+	# if we have a simple / complexType, explain right here
+	if ($type = $self->first_simpleType() )
+	{
+		$text .= $type->explain( $opt, $self->get_name() );
+		return $text;
+	}
+	elsif ($type = $self->first_complexType() )
+	{
+		$text .= $type->explain( $opt, $self->get_name() );
+		return $text;
+	}
+
+	# return if it's not a derived type - we don't handle
+	# other stuff yet.
+	return $text if (not $self->get_type() );
+
+	# if we have a derived type, fetch type and explain
+	my ($prefix, $localname) = split /:/ , $self->get_type();
+	my %ns_map = reverse %{ $opt->{ wsdl }->get_xmlns };
+
+	$type = $opt->{ wsdl }->first_types()->find_type(
+		$ns_map{ $prefix }, $localname
+	);
+
+    use Data::Dumper;
+	die "no type for $prefix:$localname ($ns_map{ $prefix })" 
+	   . Dumper $opt->{ wsdl }->first_types()->first_schema()->_DUMP
+	
+	if (not $type);
+
+	return $text .= $type->explain( $opt, $self->get_name() );
+	return 'ERROR: '. $@;
+}
+
+sub to_typemap {
+    
+    my ($self, $opt) = @_;
+    my $txt = q{};
+
+    my %nsmap = reverse %{ $opt->{ wsdl }->get_xmlns() };
+    my $type;
+
+    push @{ $opt->{path} }, $self->get_name();
+
+    if ( my $typename = $self->get_type() ) {
+        my ($prefix, $localname) = split /:/, $self->get_type();
+        my $ns = $nsmap{ $prefix };
+        my $typeclass;
+
+        # builtin type
+        if ( $nsmap{ $prefix } eq 'http://www.w3.org/2001/XMLSchema') {
+              $typeclass = "SOAP::WSDL::XSD::Typelib::Builtin::$localname";
+        }
+        else
+        {
+            $type = $opt->{ wsdl }->first_types()->find_type( $ns, $localname );
+
+            # referenced types need type_prefix (may be globally unique)
+            $typeclass = $opt->{ type_prefix } . $type->get_name();
+            $txt .= $type->to_typemap($opt);
+        }
+        $txt .= q{'} . join( q{/}, @{ $opt->{path} } ) . "' => '$typeclass',\n";
+    }
+
+    # atomic types need element prefix
+    elsif ($type = $self->first_simpleType() ) {
+        # atomic types need element prefix (may be locally unique)
+        # TODO fix simpletype Typemap
+        my $typeclass = $opt->{ element_prefix } . $self->get_name();        
+        $txt .= q{'} . join( q{/}, @{ $opt->{path} } ) . "' => '$typeclass',\n";
+
+        my $flavor = $type->get_flavor(); 
+        if ( $flavor eq 'sequence' ) {
+            $txt .= "# atomic simple type (sequence)\n";
+            $txt .= $type->to_typemap($opt). "\n";
+            $txt .= "# end atomic simple type (sequence)\n";
+        }
+        elsif ( $flavor eq 'all' ) {
+            $txt .= "# atomic simple type (all)\n";
+            $txt .= $type->to_typemap($opt). "\n";
+            $txt .= "# end atomic simple type (all)\n";
+        }
+        
+    }
+    elsif ($type = $self->first_complexType() ) {
+        my $typeclass = $opt->{ element_prefix } . $self->get_name();        
+        $txt .= q{'} . join( q{/}, @{ $opt->{path} } ) . "' => '$typeclass',\n";
+        my $flavor = $type->get_flavor()
+            || 'UNKNOWN'; 
+        if ( $flavor eq 'sequence' ) {
+            $txt .= "# atomic complex type (sequence)\n";
+            $txt .= $type->to_typemap($opt). "\n";;
+            $txt .= "# end atomic complex type (sequence)\n";
+        }
+        elsif ( $flavor eq 'all' ) {
+            $txt .= "# atomic complex type (all)\n";
+            $txt .= $type->to_typemap($opt). "\n";
+            $txt .= "# end atomic complex type (all)\n";
+        }
+        else {
+            warn "flavor $flavor in element " . $self->get_name() . "\n";
+        }
+    }
+    pop @{ $opt->{ path } };
+
+    return $txt;
+}
+
+
+sub to_class {
+    my $self = shift;
+    my $opt = shift;
+
+my $template = <<'EOT';
+package [% element_prefix %][% self.get_name %];
+use strict;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::Element;
+[% IF (type = self.first_simpleType) %]
+# <element name="[% self.get_name %]"><simpleType> definition
+use SOAP::WSDL::XSD::Typelib::SimpleType;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Element
+    SOAP::WSDL::XSD::Typelib::SimpleType
+    [% type.flavor_class %]
+    [% type.base_class($type_prefix) %]
+);
+[% ELSIF (type = self.first_complexType) %]
+# atomic complexType
+# <element name="[% self.get_name %]"><complexType> definition
+use SOAP::WSDL::XSD::Typelib::ComplexType;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Element
+    SOAP::WSDL::XSD::Typelib::ComplexType
+);
+
+[%      FOREACH element = type.get_element %]
+my %[% element.get_name %]_of :ATTR(:get<[% element.get_name %]>);
+[%      END %]
+
+__PACKAGE__->_factory(
+    [ qw([% FOREACH element = type.get_element %] 
+    [% element.get_name %]
+    [% END %]) ],
+    { 
+      [% FOREACH element = type.get_element %] [% element.get_name %] => \%[% element.get_name %]_of, 
+      [% END %]  
+    },
+    {
+      [% FOREACH element = type.get_element;
+        split_name = element.get_type.split(':');
+        prefix = split_name.0;
+        localname = split_name.1;
+        IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' %]
+        [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',        
+        [% ELSE %]
+        [% element.get_name %] => '[% type_prefix %][% localname %]',
+        [% END %] 
+      [% END %]
+    }
+);
+[%# END complexType %]
+[% ELSIF (type = self.get_type) %]
+#
+# <element name="[% self.get_name %]" type="[% self.get_type %]"/> definition
+#
+[%  split_name = self.get_type.split(':');
+    prefix = split_name.0;
+    localname = split_name.1;
+    
+    IF (nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema');
+        base_class = 'SOAP::WSDL::XSD::Typelib::Builtin::' _ localname ;
+    ELSE;
+        base_class = type_prefix _ localname;
+    -%]
+
+use [% base_class %];
+[%  END  %]
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Element
+    [% base_class %]
+);
+[% ELSIF (element = self.get_ref) 
+%]
+#   element ref"element" definition
+#   Sorry, we don't handle this yet... 
+[% END %]
+
+sub get_xmlns { '[% self.get_targetNamespace %]' }
+
+__PACKAGE__->__set_name('[% self.get_name %]');
+__PACKAGE__->__set_nillable([% self.get_nillable %]);
+__PACKAGE__->__set_minOccurs([% self.get_minOccurs %]);
+__PACKAGE__->__set_maxOccurs([% self.get_maxOccurs %]);
+__PACKAGE__->__set_ref('[% self.get_ref %]');
+
+1;
+
+
+__END__
+
+=pod
+
+=head1 NAME [% element_prefix %][% self.get_name %]
+
+=head1 SYNOPSIS
+
+=head1 DESCRIPTION
+
+Type class for the XML element [% self.get_name %]. 
+
+=head1 PROPERTIES
+
+The following properties may be accessed using get_PROPERTY / set_PROPERTY 
+methods:
+
+[%- IF (type = self.first_complexType);
+      FOREACH element = type.get_element %]
+ [% element.get_name -%]
+[%      END;
+END %]
+
+=head1 Object structure
+
+[%- IF (type = self.first_complexType);
+      FOREACH element = type.get_element;
+        split_name = element.get_type.split(':');
+        prefix = split_name.0;
+        localname = split_name.1;
+        IF nsmap.$prefix == 'http://www.w3.org/2001/XMLSchema' %]
+        [% element.get_name %] => 'SOAP::WSDL::XSD::Typelib::Builtin::[% localname %]',        
+        [% ELSE %]
+        [% element.get_name %] => '[% type_prefix %]::[% localname %]',
+        [% END; 
+      END;
+END %]
+
+Structure as perl hash: 
+
+ The object structure is displayed as hash below though this is not correct.
+ Complex hash elements actually are objects of their corresponding classes 
+ (look for classes of the same name in your typleib).
+ new() will accept a hash structure like this, but transform it to a object 
+ tree.
+
+ [% structure %]
+
+=cut
+
+EOT
+    
+    $self->SUPER::to_class($opt, $template);
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Element - XSD Element representation
+
+=head1 DESCRIPTION
+
+Represents a XML Schema Definition's Element element for serializing into
+various forms.
+
+=head1 Bugs and limitations
+
+=over
+
+=item * block
+
+Handling of the block attribute is not implemented yet.
+
+=item * final
+
+Handling of the final attribute is not implemented yet.
+
+=item * substitutionGroup
+
+Handling of the substitutionGroup attribute is not implemented yet
+
+=item * explain may produce erroneous results
+
+=back
+
+=head1 COPYING
+
+This module is part of SOAP-WSDL. See SOAP::WSDL for license.
+
+=head1 AUTHOR
+
+Insert @ instead of whitespace into e-mail.
+
+ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Primitive.pm
+++ b/lib/SOAP/WSDL/XSD/Primitive.pm
@@ -0,0 +1,50 @@
+package SOAP::WSDL::XSD::Primitive;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+use Data::Dumper;
+
+sub serialize
+{
+	my ($self, $name, $value, $opt) = @_;
+	my $xml;
+	$opt->{ indent } ||= "";
+        $opt->{ attributes } ||= [];
+        
+	$xml .= $opt->{ indent } if ($opt->{ readable });
+	$xml .= '<' . join ' ', $name, @{ $opt->{ attributes } };
+	if ( $opt->{ autotype })
+	{
+		my $ns = $self->get_targetNamespace();
+		my $prefix = $opt->{ namespace }->{ $ns }
+			|| die 'No prefix found for namespace '. $ns;
+		$xml .= ' type="' . $prefix . ':'
+			. $self->get_name() . '"' if ($self->get_name() );
+	}
+
+	if (defined $value)
+	{
+		$xml .= '>';
+		$xml .= "$value";
+		$xml .= '</' . $name . '>' ;
+	}
+	else
+	{
+		$xml .= '/>';
+	}
+	$xml .= "\n" if ($opt->{ readable });
+	return $xml;
+}
+
+sub explain
+{
+	my ($self, $opt, $name ) = @_;
+	$opt->{ indent } ||= "";
+	return "$opt->{ indent }'$name' => \$someValue,\n"
+}
+
+sub toClass {
+    warn "# primitive";
+}
+1;
--- a/lib/SOAP/WSDL/XSD/Schema.pm
+++ b/lib/SOAP/WSDL/XSD/Schema.pm
@@ -0,0 +1,72 @@
+package SOAP::WSDL::XSD::Schema;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+# child elements
+my %type_of :ATTR(:name<type> :default<[]>);
+my %element_of :ATTR(:name<element> :default<[]>);
+
+# attributes
+my %attributeFormDefault_of :ATTR(:name<attributeFormDefault> :default<()>);
+my %blockDefault_of :ATTR(:name<blockDefault> :default<()>);
+my %elementFormDefault_of :ATTR(:name<elementFormDefault> :default<()>);
+my %finalDefault_of :ATTR(:name<finalDefault> :default<()>);
+my %version_of :ATTR(:name<version> :default<()>);
+
+# id
+# name
+# targetNamespace inherited from Base
+# xmlns
+
+#
+#  attributeFormDefault = (qualified | unqualified) : unqualified
+#  blockDefault = (#all | List of (extension | restriction | substitution))  : ''
+#  elementFormDefault = (qualified | unqualified) : unqualified
+#  finalDefault = (#all | List of (extension | restriction | list | union))  : ''
+#  id = ID
+#  targetNamespace = anyURI
+#  version = token
+#  xml:lang = language
+#
+#
+# alias type with all variants
+# AUTOMETHOD is WAY too slow..
+{
+    no strict qw/refs/;
+    for my $name (qw(simpleType complexType) ) {
+        *{ "set_$name" } = \&set_type;
+        *{ "get_$name" } = \&get_type;
+        *{ "push_$name" } = \&push_type;
+        *{ "find_$name" } = \&find_type;
+    }
+}
+
+sub push_type {
+    # use $_[n] for performance -
+    # we're called on each and every type inside WSDL
+    push @{ $type_of{ ident $_[0]} }, $_[1];
+}
+
+sub find_element {
+    my ($self, @args) = @_;
+    my @found_at = grep {
+        $_->get_targetNamespace() eq $args[0] &&
+        $_->get_name() eq $args[1]
+    }
+    @{ $element_of{ ident $self } };
+    return $found_at[0];
+}
+
+sub find_type {
+    my ($self, @args) = @_;
+    my @found_at = grep {
+        $_->get_targetNamespace() eq $args[0] &&
+        $_->get_name() eq $args[1]
+    }
+    @{ $type_of{ ident $self } };
+    return $found_at[0];
+}
+
+1;
--- a/lib/SOAP/WSDL/XSD/Schema/Builtin.pm
+++ b/lib/SOAP/WSDL/XSD/Schema/Builtin.pm
@@ -0,0 +1,64 @@
+package SOAP::WSDL::XSD::Schema::Builtin;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Schema;
+use SOAP::WSDL::XSD::Primitive;
+use base qw(SOAP::WSDL::XSD::Schema);
+
+# all builtin types - add validation (e.g. content restrictions) later...
+my %PRIMITIVES = (
+	'string' => {},
+	'boolean' => {},
+	'decimal' => {},
+	'dateTime' => {},
+	'float' => {},
+	'double' => {},
+	'duration' => {},
+	'time' => {},
+	'date' => {},
+	'gYearMonth' => {},
+	'gYear' => {},
+	'gMonthDay' => {},
+	'gDay' => {},
+	'gMonth' => {},
+	'hexBinary' => {},
+	'base64Binary' => {},
+	'anyURI' => {},
+	'QName' => {},
+	'NOTATION' => {},
+	'integer' => {},
+	'non-positive-integer' => {},
+	'non-negative-integer' => {},
+	'positiveInteger' => {},
+	'negativeInteger' => {},
+    'long' => {},
+	'int' => {},
+	'unsignedInt' => {},
+	'short' => {},
+	'unsignedShort' => {},
+	'byte' => {},
+	'unsignedByte' => {},
+	'normalizedString' => {},
+	'token' => {},
+	'NMTOKEN' => {},
+);
+
+# TODO place into appropriate schema and push on schema definitions list
+# in types
+sub START {
+	my $self = shift;
+	my @args = @_;
+
+	while (my ($name, $value) = each %PRIMITIVES )
+	{
+		$self->push_type( SOAP::WSDL::XSD::Primitive->new({
+                name => $name,
+                targetNamespace => 'http://www.w3.org/2001/XMLSchema',
+            } )
+		);
+	}
+    return $self;
+}
+
+1;
--- a/lib/SOAP/WSDL/XSD/SimpleType.pm
+++ b/lib/SOAP/WSDL/XSD/SimpleType.pm
@@ -0,0 +1,179 @@
+package SOAP::WSDL::XSD::SimpleType;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::Base);
+
+my %base_of         :ATTR(:name<base>           :default<()>);
+my %itemType_of     :ATTR(:name<itemType>       :default<()>);
+my %enumeration_of  :ATTR(:name<enumeration>    :default<()>);
+# is set to simpleContent/complexContent
+my %content_Model_of    :ATTR(:name<contentModel>   :default<()>);
+
+# set to restriction|list|union|enumeration
+my %flavor_of       :ATTR(:name<flavor>         :default<()>);
+
+sub set_restriction {
+    my $self = shift;
+    my @attributes = @_;
+    $self->set_flavor( 'restriction' );
+    for (@attributes) {
+        next if (not $_->{ LocalName } eq 'base');
+        $self->set_base( $_->{ Value } );
+    }
+}
+
+sub set_list {
+    my $self = shift;
+    my @attributes = @_;
+    $self->set_flavor( 'list' );
+    for (@attributes) {
+        next if (not $_->{ LocalName } eq 'type');
+        $self->set_base( $_->{ Value } );
+    }
+}
+
+sub set_union {
+    my $self = shift;
+    my @attributes = @_;
+    $self->set_flavor( 'union' );
+    for (@attributes) {
+        next if (not $_->{ LocalName } eq 'memberTypes');
+        $self->set_base( [ split /\s/, $_->{ Value } ] );
+    }
+}
+
+sub push_enumeration
+{
+	my $self = shift;
+	my @attr = @_;
+	my @attributes = @_;
+	$self->set_flavor( 'enumeration' );
+	for (@attributes) {
+		next if (not $_->{ LocalName } eq 'value');
+		push @{ $enumeration_of{ ident $self } }, $_->{ 'Value' };
+	}
+}
+
+sub serialize {
+    my $self = shift;
+    my $name = shift;
+    my $value = shift;
+    my $opt = shift;
+    my $ident = ident $self;
+    
+    $opt->{ attributes } ||= [];
+    $opt->{ indent } ||= q{};
+    
+    $self->_check_value( $value );
+    
+    return $self->_serialize_single($name, $value , $opt)
+      if ( $flavor_of{ $ident } eq 'restriction'
+        or $flavor_of{ $ident } eq 'union'
+        or $flavor_of{ $ident } eq 'enumeration');
+
+    if ($flavor_of{ $ident } eq 'list' )
+    {
+        $value ||= [];
+        $value = [ $value ] if ( ref( $value) ne 'ARRAY' );
+        return $self->_serialize_single($name, join( q{ }, @{ $value } ), $opt);
+    }
+}
+
+sub _serialize_single {
+    my ($self, $name, $value, $opt) = @_;
+    my $xml = '';
+    $xml .= $opt->{ indent } if ($opt->{ readable });	# add indentation
+    $xml .= '<' . join ' ', $name, @{ $opt->{ attributes } };
+    if ( $opt->{ autotype }) {
+        my $ns = $self->get_targetNamespace();
+        my $prefix = $opt->{ namespace }->{ $ns }
+           || die 'No prefix found for namespace '. $ns;
+        $xml .= ' type="' . $prefix . ':' . $self->get_name() .'"';
+    }
+    
+    # nillabel ?
+    return $xml .'/>' if not defined $value;
+    
+    $xml .= join q{}, '>' , $value , '</' , $name , '>';
+    $xml .= "\n" if ($opt->{ readable });
+    return $xml;
+}
+
+sub explain {
+    my ($self, $opt, $name) = @_;
+    my $perl;
+    $opt->{ indent } ||= "";
+    $perl .= $opt->{ indent } if ($opt->{ readable });
+    $perl .= q{'} . $name . q{' => $someValue };
+    $perl .= "\n" if ($opt->{ readable });
+    return $perl;
+}
+
+sub _check_value {
+	my $self = shift;
+}
+
+# TODO: implement to_class based on template...
+
+sub to_class {
+    my $self = shift;
+    my $opt = shift;
+    my $class_prefix = $opt->{ type_prefix };
+    my $name = $opt->{name} || $self->get_name();
+    my $flavor = $self->get_flavor() eq 'list' 
+        ? 'SOAP::WSDL::XSD::Typelib::Builtin::list'
+        : $self->get_flavor() eq 'restriction' 
+            ? 'SOAP::WSDL::XSD::Typelib::SimpleType::restriction'
+            : q{};
+    my $base = $self->get_base();
+    my $targetNamespace = $self->get_targetNamespace;
+    my ($prefix, $localname) = split /:/, $base;
+    my %ns_map = reverse %{ $opt->{ wsdl }->get_xmlns() };
+    $base = ($ns_map{ $prefix} eq 'http://www.w3.org/2001/XMLSchema') 
+        ? "SOAP::WSDL::XSD::Typelib::Builtin::$localname"
+        : "$opt->{prefix}::$localname";
+    
+    my $code =<<"EOT";
+package $class_prefix::$name;
+use strict;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+use SOAP::WSDL::XSD::Typelib::SimpleType;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::SimpleType
+    $flavor
+    $base
+);
+
+1;
+
+sub get_xmlns { '$targetNamespace' }
+
+EOT
+
+    return $code;
+}
+
+
+1;
+
+=pod
+
+=head1 Bugs and limitations
+
+=over
+
+=item * simpleContent, complexContent
+
+These child elements are not implemented yet
+
+=item * union
+
+union simpleType definitions probalbly serialize wrong
+
+=item * explain may produce erroneous results
+
+=back
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin.pm
@@ -0,0 +1,205 @@
+package SOAP::WSDL::XSD::Typelib::Builtin;
+use strict;
+use warnings;
+use Class::Std::Storable;
+
+use SOAP::WSDL::XSD::Typelib::Builtin::anyType;
+use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
+use SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
+use SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
+use SOAP::WSDL::XSD::Typelib::Builtin::boolean;
+use SOAP::WSDL::XSD::Typelib::Builtin::byte;
+use SOAP::WSDL::XSD::Typelib::Builtin::date;
+use SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
+use SOAP::WSDL::XSD::Typelib::Builtin::decimal;
+use SOAP::WSDL::XSD::Typelib::Builtin::double;
+use SOAP::WSDL::XSD::Typelib::Builtin::duration;
+use SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
+use SOAP::WSDL::XSD::Typelib::Builtin::float;
+use SOAP::WSDL::XSD::Typelib::Builtin::gDay;
+use SOAP::WSDL::XSD::Typelib::Builtin::gMonth;
+use SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
+use SOAP::WSDL::XSD::Typelib::Builtin::gYear;
+use SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
+use SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
+use SOAP::WSDL::XSD::Typelib::Builtin::ID;
+use SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
+use SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
+use SOAP::WSDL::XSD::Typelib::Builtin::int;
+use SOAP::WSDL::XSD::Typelib::Builtin::integer;
+use SOAP::WSDL::XSD::Typelib::Builtin::language;
+use SOAP::WSDL::XSD::Typelib::Builtin::list;
+use SOAP::WSDL::XSD::Typelib::Builtin::long;
+use SOAP::WSDL::XSD::Typelib::Builtin::Name;
+use SOAP::WSDL::XSD::Typelib::Builtin::NCName;
+use SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
+use SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
+use SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
+use SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
+use SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
+use SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
+use SOAP::WSDL::XSD::Typelib::Builtin::QName;
+use SOAP::WSDL::XSD::Typelib::Builtin::short;
+use SOAP::WSDL::XSD::Typelib::Builtin::string;
+use SOAP::WSDL::XSD::Typelib::Builtin::time;
+use SOAP::WSDL::XSD::Typelib::Builtin::token;
+use SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
+use SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
+use SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
+use SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin - Built-in XML Schema datatypes
+
+=head1 DESCRIPTION
+
+This module implements all builtin Types from the XML schema specification.
+
+Objects of a class may be filled with values and serialize correctly.
+
+These basic type classes are most useful when used as element or simpleType
+base classes.
+
+The datatypes classes themselves are split up into 
+SOAP::WSDL::XSD::Typelib::Builtin::* modules. 
+
+Using SOAP::WSDL::XSD::Typelib::Builtin uses all of the builtin datatype 
+classes.
+
+=head1 EXAMPLES
+
+ my $bool = SOAP::WSDL::XSD::Typelib::Builtin::bool->new({ value => 0} );
+ print $bool;    # prints "true"
+
+ # implements <simpleType name="MySimpleType">
+ #               <list itemType="xsd:string" />
+ #            </simpleType>
+ package MySimpleType;
+ use SOAP::WSDL::XSD::Typelib::Builtin;
+ use SOAP::WSDL::XSD::Typelib::SimpleType;
+
+ use base qw(SOAP::WSDL::XSD::Typelib::SimpleType
+    SOAP::WSDL::XSD::Typelib::Builtin::list
+    SOAP::WSDL::XSD::Typelib::Builtin::string
+ );
+ 1;
+
+ # somewhere else
+ my $list = MySimpleType->new({ value => [ 'You', 'shall', 'overcome' ] });
+ print $list;   # prints "You shall overcome"
+
+=head1 CLASS HIERARCHY
+
+This is the inheritance graph for builtin types.
+
+Types with [] marker describe types derived via the item in [] in the XML
+Schema specs.
+
+Derivation is implemented via multiple inheritance with the derivation method
+as first item in the base class list.
+
+ anyType
+ - anySimpleType
+     - duration
+     - dateTime
+     - date
+     - time
+     - gYearMonth
+     - gYear
+     - gMonthDay
+     - gDay
+     - gMonth
+     - boolean
+     - base64Binary
+     - hexBinary
+     - float
+     - decimal
+         - integer
+         - nonPositiveInteger
+             - negativeInteger
+         - nonNegativeInteger
+             - positiveInteger
+             - unsignedLong
+             - unsignedInt
+             - unsignedShort
+             - unsignedByte
+         - long
+             - int
+                 - short
+                     - byte
+     - double
+     - anyURI
+     - string
+          - normalizedString
+              - language
+              - Name
+                  - NCName
+                      - ID
+                      - IDREF
+                          - IDREFS [list]
+                      - ENTITY
+              - NMTOKEN
+                  - NMTOKENS [list]
+
+=head1 OVERLOADED OPERATORS
+
+Overloading is implemented via Class::Std's trait mechanism.
+
+The following behaviours apply:
+
+=over
+
+=item * string context
+
+All classes use the C<serialize> method for stringification.
+
+=item * bool context
+
+All classes derived from anySimpleType return their value in bool context
+
+=item * numeric context
+
+The boolean class returns 0 or 1 in numeric context.
+
+decimal, float and double (and derived classes) return their value in
+numeric context.
+
+=back
+
+=head1 BUGS AND LIMITATIONS
+
+=over
+
+=item * Thread safety
+
+SOAP::WSDL::XSD::Typelib::Builtin uses Class::Std::Storable which uses
+Class::Std. Class::Std is not thread safe, so
+SOAP::WSDL::XSD::Typelib::Builtin is neither.
+
+=item * XML Schema facets
+
+No facets are implemented yet.
+
+=back
+
+=head1 AUTHOR
+
+Replace whitespace by @ in e-mail address.
+
+ Martin Kutter E<gt>martin.kutter fen-net.deE<lt>
+
+=head1 Licenxe
+
+Copyright 2004-2007 Martin Kutter.
+
+This library is free software, you may distribute/modify it under the
+same terms as perl itself
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.pm
@@ -0,0 +1,27 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::NCName);
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::ENTITY - ENTITY objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/ID.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/ID.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::ID;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::NCName);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::ID - ID objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::ID);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::IDREF - IDREF objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.pm
@@ -0,0 +1,32 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Builtin::list
+    SOAP::WSDL::XSD::Typelib::Builtin::IDREF);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::IDREFS - IDREFS objects
+
+=head1 DESCRIPTION
+
+IDREFS is a list datatype implemented by list derivation from IDREF.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/NCName.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/NCName.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::NCName;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::Name);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::NCName - NCName objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN - NMTOKEN objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.pm
@@ -0,0 +1,33 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(
+    SOAP::WSDL::XSD::Typelib::Builtin::list
+    SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN);
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS - NMTOKENS objects
+
+=head1 DESCRIPTION
+
+List of NMTOKEN objects.
+
+Implemented by derivation via SOAP::WSDL::XSD::Typelib::Builtin::list.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.pm
@@ -0,0 +1,45 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::NOTATION - NOTATION object
+
+=head1 DESCRIPTION
+
+NOTATION represents the NOTATION attribute type from 
+XML 1.0 (Second Edition)
+
+=head1 BUGS AND LIMITATIONS
+
+Facets are implemented but don't have any influence yet.
+
+No constraints are implemented yet.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/Name.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/Name.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::Name;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::Name - Name objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/QName.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/QName.pm
@@ -0,0 +1,45 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::QName;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::QName - qualified Name object
+
+=head1 DESCRIPTION
+
+QName represents XML qualified names. The <20>value space<63> of QName 
+is the set of tuples {namespace name, local part}, where namespace 
+name is an anyURI and local part is an NCName. 
+
+=head1 BUGS AND LIMITATIONS
+
+Facets are implemented but don't have any influence yet.
+
+No constraints are implemented yet.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.pm
@@ -0,0 +1,70 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
+use strict;
+use warnings;
+
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
+}
+
+my %value_of :ATTR(:get<value> :init_arg<value> :default<()>);
+
+## use $_[n] for speed - we get called zillions of times...
+# and we don't need to return the last value...
+sub set_value { $value_of{ ident $_[0] } = $_[1] }
+
+sub serialize {
+    my ($self, $opt) = @_;
+    my $ident = ident $self;
+    $opt ||= {};
+    return $self->start_tag({ %$opt, nil => 1})
+        if not defined $value_of{ $ident };
+    return join q{}, $self->start_tag($opt, $value_of{ $ident })
+        , $value_of{ $ident }
+        , $self->end_tag($opt);
+}
+
+# TODO disallow serializing !
+sub as_bool :BOOLIFY {
+    return $value_of { ident $_[0] };
+}
+
+Class::Std::initialize();   # make :BOOLIFY overloading serializable
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType - All builtin and all simpleType types inherit from anySimpleType
+
+=head1 CAVEATS
+
+=over
+
+=item * set_value
+
+In contrast to Class::Std-generated mutators (setters), set_value does 
+not return the last value.
+
+This is for speed reasons: SOAP::WSDL never needs to know the last value 
+when calling set_calue, but calls it over and over again...
+
+=back
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/anyType.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/anyType.pm
@@ -0,0 +1,49 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::anyType;
+use strict;
+use warnings;
+use Class::Std::Storable;
+
+my %xmlns_of :ATTR(:name<xmlns> :default<()>);
+
+# use $_[1] for performance
+sub start_tag { 
+    my $opt = $_[1] ||= {};
+    return '<' . $opt->{name} . ' >' if $opt->{ name };
+    return q{}
+}
+
+# use $_[1] for performance
+sub end_tag { 
+    return $_[1] && defined $_[1]->{ name }
+        ? "</$_[1]->{name} >"
+        : q{};
+};
+
+sub serialize_qualified :STRINGIFY {
+    return $_[0]->serialize( { qualified => 1 } );
+}
+
+Class::Std::initialize();           # make :STRINGIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::anyType - Base of all XSD Types
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.pm
@@ -0,0 +1,48 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::anyURI - URI object
+
+=head1 DESCRIPTION
+
+anyURI represents a Uniform Resource Identifier Reference (URI). 
+An anyURI value can be absolute or relative, and may have an optional 
+fragment identifier (i.e., it may be a URI Reference).
+
+=head1 BUGS AND LIMITATIONS
+
+Facets are implemented but don't have any influence yet.
+
+No constraints are implemented yet.
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.pm
@@ -0,0 +1,35 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::base64Binary - base64 encoded binary objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/boolean.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/boolean.pm
@@ -0,0 +1,92 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::boolean;
+use strict;
+use warnings;
+
+# Speed up. Class::Std::new is slow - and we don't need it's functionality...
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+}
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %value_of            :ATTR(:get<value> :init_attr<value> :default<()>);
+
+{
+    no warnings qw(redefine);
+    no strict qw(refs);
+
+    # Yes, I know it's ugly - but this is the fastest constructor to write 
+    # for Class::Std-Style inside out objects..
+    *{ __PACKAGE__ . '::new' } = sub {   
+        my $self = bless \do { my $foo } , shift;
+        if (@_) {
+            $value_of{ ident $self } = $_[0]->{ value }
+                if exists $_[0]->{ value }
+        }
+        return $self;
+    };
+
+}
+
+
+sub serialize {
+    my ($self, $opt) = @_;
+    my $ident = ident $self;
+    $opt ||= {};
+    return $self->start_tag({ %$opt, nil => 1})
+            if not defined $value_of{ $ident };
+    return join q{}
+        , $self->start_tag($opt)
+        , $value_of{ $ident } ? 'true' : 'false'
+        , $self->end_tag($opt);
+}
+
+sub as_num :NUMERIFY {
+    return $_[0]->get_value();
+}
+
+sub set_value {
+    my ($self, $value) = @_;
+    $value_of{ ident $self } = defined $value
+        ? ($value ne 'false' or ($value))
+            ? 1 : 0
+        : 0;
+}
+
+
+
+Class::Std::initialize();   # make :BOOLIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::boolean - boolean objects
+
+=head1 DESCRIPTION
+
+Serializes to "true" or "false".
+
+Everything true in perl and not "false" is deserialized as true.
+
+Returns true/false in boolean context.
+
+Returns 1 / 0 in numeric context.
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/byte.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/byte.pm
@@ -0,0 +1,33 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::byte;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::short);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::byte - byte integer objects
+
+=head1 DESCRIPTION
+
+Subclass of short.
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/date.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/date.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::date;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::date - date objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.pm
@@ -0,0 +1,37 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::dateTime - dateTime objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
+
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/decimal.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/decimal.pm
@@ -0,0 +1,44 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::decimal;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %totalDigits_of      :ATTR(:name<totalDigits> :default<()>);
+my %fractionDigits_of   :ATTR(:name<fractionDigits> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+sub as_num :NUMERIFY :BOOLIFY {
+    return $_[0]->get_value();
+}
+
+Class::Std::initialize();   # make :NUMERIFY :BOOLIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::decimal - decimal object, base of all non-float numbers
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/double.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/double.pm
@@ -0,0 +1,56 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::double;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+sub as_num :NUMERIFY {
+    return $_[0]->get_value();
+}
+
+Class::Std::initialize();   # make :NUMERIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::double - double precision float objects
+
+=head1 DESCRIPTION
+
+The double datatype corresponds to IEEE double-precision 64-bit floating point type. 
+The basic <20>value space<63> of double consists of the values m <20> 2^e, where m is an 
+integer whose absolute value is less than 2^53, and e is an integer between 
+-1075 and 970, inclusive. 
+
+In addition to the basic <20>value space<63> described above, the <20>value space<63> of double 
+also contains the following special values: positive and negative zero, positive and 
+negative infinity and not-a-number. The <20>order-relation<6F> on double is: 
+
+ x < y iff y - x is positive. 
+ 
+Positive zero is greater than negative zero. 
+
+Not-a-number equals itself and is greater than all double values including 
+positive infinity.
+
+=head1 BUGS AND LIMITATIONS
+
+None of the "special" behaviours and values are implemented yet.
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/duration.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/duration.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::duration;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::duration - duration objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/float.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/float.pm
@@ -0,0 +1,43 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::float;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+
+sub as_num :NUMERIFY {
+    return $_[0]->get_value();
+}
+
+Class::Std::initialize();   # make :NUMERIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::float - float objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/gDay.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/gDay.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::gDay;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::gDay - day objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonth.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonth.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::gMonth;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::gMonth - month objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonthDay.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonthDay.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay - month day objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/gYear.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/gYear.pm
@@ -0,0 +1,36 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::gYear;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::gYear - year objects
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/gYearMonth.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/gYearMonth.pm
@@ -0,0 +1,34 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth - year and month objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.pm
@@ -0,0 +1,33 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::hexBinary - hex encoded binary objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/int.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/int.pm
@@ -0,0 +1,49 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::int;
+use strict;
+use warnings;
+
+# Speed up. Class::Std::new is slow - and we don't need it's functionality...
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::long);
+
+    no warnings qw(redefine);
+    no strict qw(refs);
+
+    # Yes, I know it's ugly - but this is the fastest constructor to write 
+    # for Class::Std-Style inside out objects..
+    *{ __PACKAGE__ . '::new' } = sub {   
+        my $self = bless \do { my $foo } , shift;
+        if (@_) {
+            $self->set_value( $_[0]->{ value } )
+                if exists $_[0]->{ value }
+        }
+        return $self;
+    };
+
+};
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::int - int objects
+
+=head1 DESCRIPTION
+
+Subclass of long.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/integer.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/integer.pm
@@ -0,0 +1,52 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::integer;
+use strict;
+use warnings;
+
+# Speed up. Class::Std::new is slow - and we don't need it's functionality...
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::decimal);
+
+    no warnings qw(redefine);
+    no strict qw(refs);
+
+    # Yes, I know it's ugly - but this is the fastest constructor to write 
+    # for Class::Std-Style inside out objects..
+    *{ __PACKAGE__ . '::new' } = sub {   
+        my $self = bless \do { my $foo } , shift;
+        if (@_) {
+            $self->set_value( $_[0]->{ value } )
+                if exists $_[0]->{ value }
+        }
+        return $self;
+    };
+
+};
+
+
+sub as_num :NUMERIFY {
+    return $_[0]->get_value();
+}
+
+Class::Std::initialize();       # make :NUMERIFY overloading serializable
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::integer - integer objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/language.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/language.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::language;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::language - language objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/list.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/list.pm
@@ -0,0 +1,41 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::list;
+use strict;
+use warnings;
+use Class::Std::Storable;
+
+sub serialize {
+    my ($self, $opt) = @_;
+    my $value = $self->get_value();
+    return $self->start_tag({ %$opt, nil => 1 }) if not defined $value;
+    $value = [ $value ] if not ref $value;
+    return join q{}, $self->start_tag($opt, $value)
+        , join( q{ }, @{ $value } )
+        , $self->end_tag($opt, $value);
+}
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::list - list derivation base class
+
+=head1 DESCRIPTION
+
+To derive from some class by list, just inherit from list.
+  
+Make sure SOAP::WSDL::XSD::Typelib::Builtin::list is before the type 
+to derive from in the @ISA list.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/long.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/long.pm
@@ -0,0 +1,50 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::long;
+use strict;
+use warnings;
+
+# Speed up. Class::Std::new is slow - and we don't need it's functionality...
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
+
+    no warnings qw(redefine);
+    no strict qw(refs);
+
+    # Yes, I know it's ugly - but this is the fastest constructor to write 
+    # for Class::Std-Style inside out objects..
+    *{ __PACKAGE__ . '::new' } = sub {   
+        my $self = bless \do { my $foo } , shift;
+        if (@_) {
+            $self->set_value( $_[0]->{ value } )
+                if exists $_[0]->{ value }
+        }
+        return $self;
+    };
+
+};
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::long - long integer objects
+
+=head1 DESCRIPTION
+
+Subclass of integer.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.pm
@@ -0,0 +1,30 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::egativeInteger - negative integer objects
+
+=head1 DESCRIPTION
+
+Subclass of integer.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.pm
@@ -0,0 +1,30 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger - non negative integer objects
+
+=head1 DESCRIPTION
+
+Subclass of integer.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.pm
@@ -0,0 +1,30 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger - nonPositiveInteger objects
+
+=head1 DESCRIPTION
+
+Subclass of integer.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::string);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::normalizedString - normalizedString objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.pm
@@ -0,0 +1,31 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger - positive integer objects
+
+=head1 DESCRIPTION
+
+Subclass of nonNegativeInteger.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/short.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/short.pm
@@ -0,0 +1,31 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::short;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::int);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::short - short int objects
+
+=head1 DESCRIPTION
+
+Subclass of int.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/string.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/string.pm
@@ -0,0 +1,85 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::string;
+use strict;
+use warnings;
+
+# Speed up. Class::Std::new is slow - and we don't need it's functionality...
+BEGIN {
+    use Class::Std::Storable;
+    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+    no warnings qw(redefine);
+    no strict qw(refs);
+
+    # Yes, I know it's ugly - but this is the fastest constructor to write 
+    # for Class::Std-Style inside out objects..
+    *{ __PACKAGE__ . '::new' } = sub {   
+        my $self = bless \do { my $foo } , shift;
+        if (@_) {
+            $self->set_value( $_[0]->{ value } )
+                if exists $_[0]->{ value }
+        }
+        return $self;
+    };
+
+}
+
+my %length_of           :ATTR(:name<length> :default<()>);
+my %minLength_of        :ATTR(:name<minLength> :default<()>);
+my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+
+
+
+my %char2entity = (
+    q{&} => q{&amp;},
+    q{<} => q{&lt;},
+    q{>} => q{&gt;},
+    q{"} => q{&qout;},
+    q{'} => q{&apos;},
+);
+
+
+sub serialize {
+    my ($self, $opt) = @_;
+    my $ident = ident $self;
+    $opt ||= {};
+    my $value = $self->get_value();
+    return $self->start_tag({ %$opt, nil => 1})
+        if not defined $value;
+
+    # HTML::Entities does the same - and more, thus it's around 1/3 slower...
+    $value =~ s{([&<>"'])}{$char2entity{$1}}xgmso;
+
+    return join q{}, $self->start_tag($opt, $value)
+        #, encode_entities( $value, q{&<>"'} )
+        , $value
+        , $self->end_tag($opt);
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::string - string objects
+
+=head1 DESCRIPTION
+
+String objects. XML entities (&, E<lt> E<gt> " ') are encoded on 
+serialization.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/time.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/time.pm
@@ -0,0 +1,34 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::time;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
+
+my %pattern_of          :ATTR(:name<pattern> :default<()>);
+my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
+my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
+my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
+my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
+my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::time - time objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/token.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/token.pm
@@ -0,0 +1,26 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::token;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::normalizedString);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::token - token objects
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.pm
@@ -0,0 +1,31 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte - unsigned byte objects
+
+=head1 DESCRIPTION
+
+Subclass of unsignedShort.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.pm
@@ -0,0 +1,32 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt - unsigned int objects
+
+=head1 DESCRIPTION
+
+Subclass of unsignedLong.
+
+=head1 LICENSE
+
+Copyright 2004-2007 Martin Kutter.
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.pm
@@ -0,0 +1,31 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong - unsigned long integer objects
+
+=head1 DESCRIPTION
+
+Subclass of nonNegativeInteger.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.pm
@@ -0,0 +1,31 @@
+package SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
+use strict;
+use warnings;
+use Class::Std::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt);
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort - unsigned short integer objects
+
+=head1 DESCRIPTION
+
+Subclass of unsignedInt.
+
+=head1 LICENSE
+
+This file is part of SOAP-WSDL. You may distribute/modify it under 
+the same terms as perl itself
+
+=head1 AUTHOR
+
+Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm
@@ -0,0 +1,218 @@
+#!/usr/bin/perl
+package SOAP::WSDL::XSD::Typelib::ComplexType;
+use strict;
+use Carp;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+use Scalar::Util qw(blessed);
+use Class::Std::Storable;
+
+use Data::Dumper;
+
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
+
+my %ELEMENTS_FROM;
+my %ATTRIBUTES_OF;
+my %CLASSES_OF;
+
+# we store per-class elements.
+# call as __PACKAGE__->_factory
+sub _factory {
+    my $class = shift;
+    $ELEMENTS_FROM{ $class } = shift;
+    $ATTRIBUTES_OF{ $class } = shift;
+    $CLASSES_OF{ $class } = shift;
+
+    no strict qw(refs);
+    no warnings qw(redefine); 
+    while (my ($name, $attribute_ref) = each %{ $ATTRIBUTES_OF{ $class } } )
+    {
+        my $type = $CLASSES_OF{ $class }->{ $name }
+            or die "No class given for $name";
+
+        $type->isa('UNIVERSAL')
+            or eval "require $type" 
+                or croak $@;
+
+        *{ "$class\::set_$name" } = sub  {
+            my ($self, $value) = @_;
+            
+            # we accept:
+            # a) objects
+            # b) scalars            
+            # c) list refs
+            # d) hash refs
+            # e) mixed stuff of all of the above, so we have to 
+            # set our element to 
+            # a) value if it's an object
+            # b) New object with value for simple values
+            # c 1) New object with value for list values and list type
+            # c 2) List ref of new objects with value for list values and non-list type
+            # c + e) List ref of objects for list values (list of objects) and non-list type
+            # d) New object with values passed to new for HASH references
+            # 
+            # Die on non-ARRAY/HASH references - if you can define semantics 
+            # for GLOB references, feel free to add them.
+            $attribute_ref->{ ident $self } = blessed $value
+                ? $value
+                : ref $value 
+                    ? ref $value eq 'ARRAY' 
+                        ?  $type->isa('SOAP::WSDL::XSD::Typelib::Builtin::list')
+                            ? $type->new({ value => $value })
+                            : [ map { 
+                                    blessed($_) 
+                                        ? ($_->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType'))
+                                            ? $_
+                                            : croak 'cannot use non-XSD object as value'
+                                        : $type->new({ value => $_ })
+                                } @{ $value } 
+                             ]
+                    : ref $value eq 'HASH' 
+                        ?  $type->new( $value )
+                        :  die 'Cannot use non-ARRAY/HASH as data'
+                : $type->new({ value => $value });                     
+        };
+
+        *{ "$class\::add_$name" } = sub {
+            my ($self, $value) = @_;
+            my $ident = ident $self;
+            if (not defined $value) {
+                warn "attempting to add empty value to " . ref $self;
+            }
+            
+            return $attribute_ref->{ $ident } = $value
+                if not defined $attribute_ref->{ $ident };
+
+            # listify previous value if it's no list
+            $attribute_ref->{ $ident } = [  $attribute_ref->{ $ident } ]
+                if not ref $attribute_ref->{ $ident } eq 'ARRAY';
+
+            # add to list
+            return push @{ $attribute_ref->{ $ident } }, $value;                                          
+        };
+        
+        *{ "$class\::START" } = sub {
+            my ($self, $ident, $args_of) = @_;
+        
+            # iterate over keys of arguments 
+            # and call set appropriate field in clase
+            map { ($ATTRIBUTES_OF{ $class }->{ $_ }) 
+               ? do {
+                    my $method = "set_$_";
+                    $self->$method( $args_of->{ $_ } );    
+               }
+               : $_ =~ m{ \A              # beginning of string
+                          xmlns           # xmlns 
+                    }xms  
+                    ? do {}
+                    : do { use Data::Dumper; 
+                        croak "unknown field $_ in $class. Valid fields are " 
+                          . join(', ', @{ $ELEMENTS_FROM{ $class } }) . "\n"
+                          . Dumper @_ };
+            # TODO maybe only warn for unknown fields ?
+        
+            } keys %$args_of;
+        };
+
+        # this serialize method works fine for <all> and <sequence>
+        # complextypes, as well as for <restriction><all> or
+        # <restriction><sequence>.
+        # But what about choice, group, extension ?
+        #
+        *{ "$class\::_serialize" } = sub {
+            my $ident = ident $_[0];
+            # my $class = ref $_[0];
+
+            # return concatenated return value of serialize call of all
+            # elements retrieved from get_elements expanding list refs.
+            # get_elements is inlined for performance.
+            return join q{} , map {     
+                my $element = $ATTRIBUTES_OF{ $class }->{ $_ }->{ $ident };
+                
+                if (defined $element) {       
+                    $element = [ $element ]
+                        if not ref $element eq 'ARRAY';
+                    my $name = $_;
+            
+                    map {
+                        # serialize element elements with their own serializer
+                        # but name them like they're named here.
+                        if ( $_->isa( 'SOAP::WSDL::XSD::Typelib::Element' ) ) {
+                                $_->serialize( { name => $name } );
+                        }
+                        # serialize complextype elments (of other types) with their 
+                        # serializer, but add element tags around.
+                        else {
+                            join q{}, $_->start_tag({ name => $name })
+                                , $_->serialize()
+                                , $_->end_tag({ name => $name });       
+                        }
+                    } @{ $element }
+                }
+                else {
+                    q{};
+                }        
+            } (@{ $ELEMENTS_FROM{ $class } });
+        };
+
+        *{ "$class\::serialize" } = sub {
+            my ($self, $opt) = @_;
+            $opt ||= {};
+        
+            # do we have a empty element ? 
+            return $self->start_tag({ %$opt, empty => 1 })
+                if not defined $ELEMENTS_FROM{ $class } or not @{ $ELEMENTS_FROM{ $class } };
+            return join q{}, $self->start_tag($opt),
+                    $self->_serialize(), $self->end_tag();
+        }
+
+    }
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::ComplexType - ComplexType XML Schema definitions
+
+=head1 Bugs and limitations
+
+=over
+
+=item * Incomplete API
+
+Not all variants of XML Schema ComplexType definitions are supported yet.
+
+Variants known to work are:
+
+ sequence
+ all
+ complexContent containing sequence/all definitions
+ 
+=item * Thread safety
+
+SOAP::WSDL::XSD::Typelib::Builtin uses Class::Std::Storable which uses
+Class::Std. Class::Std is not thread safe, so
+SOAP::WSDL::XSD::Typelib::Builtin is neither.
+
+=item * XML Schema facets
+
+No facets are implemented yet.
+
+=back
+
+=head1 AUTHOR
+
+Replace whitespace by @ in e-mail address.
+
+ Martin Kutter E<gt>martin.kutter fen-net.deE<lt>
+
+=head1 COPYING
+
+This library is free software, you may distribute/modify it under the
+same terms as perl itself
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/Element.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/Element.pm
@@ -0,0 +1,102 @@
+#!/usr/bin/perl
+package SOAP::WSDL::XSD::Typelib::Element;
+use strict;
+use Class::Std::Storable;
+use Data::Dumper;
+
+my %NAME;
+my %NILLABLE;
+my %REF;
+my %MIN_OCCURS;
+my %MAX_OCCURS;
+
+# Class data - remember, we're the base class for a class factory or for
+# generated code...
+# use BLOCK: for scoping
+BLOCK: {
+    my %method_lookup = (
+        _name => \%NAME,
+        _nillable => \%NILLABLE,
+        _ref => \%REF,
+        _minOccurs => \%MIN_OCCURS,
+        _maxOccurs => \%MAX_OCCURS,
+    );
+
+    no strict qw(refs);
+    while (my ($name, $value) = each %method_lookup ) {
+        *{ "__set$name" } = sub {
+            my $class = ref $_[0] || $_[0];
+            $value->{ $class } = $_[1];
+        };
+        *{ "__get$name" } = sub {
+            my $class = ref $_[0] || $_[0];
+            return $value->{ $class };
+        };
+    }
+};
+
+sub start_tag {
+    my ($self, $opt, $value) = @_;
+    my $class = ref $self;
+    my $ending = '>';
+    my @attr_from = ();
+    my $name = $opt->{ name } || $NAME{$class};
+    $ending = '/>' if ($opt->{ empty });
+    
+    if ($opt->{qualified}) {
+        push @attr_from, 'xmlns="' . $self->get_xmlns . '"';
+    }
+    if ($opt->{ nil }) {
+        return q{} if not $NILLABLE{ $class };
+        push @attr_from, 'xsi:nil="true"';
+        $ending = '/>';
+    }
+    return join q{ }, "<$name" , @attr_from , $ending;
+}
+
+sub end_tag {
+    my ($class, $opt) = (ref $_[0], $_[1]);
+    my $name = $opt->{ name } || $NAME{$class};
+    return "</$name>";
+}
+
+1;
+
+=pod
+
+=head1 SYNOPSIS
+
+ package MyElement;
+ use strict;
+ use Class::Std::Storable;
+ use base (
+    'SOAP::WSDL::XSD::Typelib::Element',
+ );
+
+ __PACKAGE__->__set_name('MyElementName');
+ __PACKAGE__->__set_nillable(1);
+ __PACKAGE__->__set_minOccurs(1);
+ __PACKAGE__->__set_maxOccurs(1);
+ __PACKAGE__->__set_ref(1);
+
+=head1 BUGS AND LIMITATIONS
+
+=over
+
+=item * minOccurs maxOccurs ref not implemented
+
+These attributes are not yet supported, though they may be set as class
+properties via __PACKAGE__->__set_FOO methods.
+
+=item * 'http://www.w3.org/2001/XMLSchema-instance prefix is hardcoded
+
+The prefix for 'http://www.w3.org/2001/XMLSchema-instance (used as namespace
+for the {http://www.w3.org/2001/XMLSchema-instance}nil="true" attribute
+is hardcoded as 'xsi'.
+
+You should definitly provide your XML envelope generator with the same prefix
+namespace combination (Default for SOAP::WSDL::Envelope).
+
+=back
+
+=cut
--- a/lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
+++ b/lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm
@@ -0,0 +1,132 @@
+#!/usr/bin/perl
+package SOAP::WSDL::XSD::Typelib::SimpleType;
+use strict;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+
+package SOAP::WSDL::XSD::Typelib::SimpleType::restriction;
+use strict;
+use Class::Std::Storable;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+use base qw(SOAP::WSDL::XSD::Typelib::SimpleType);
+
+1;
+__END__
+
+=pod
+
+=head1 NAME
+
+SOAP::WSDL::XSD::Typelib::SimpleType - simple type base class
+
+=head1 DESCRIPTION
+
+This module implements a base class for designing simple type classes
+modelling XML Schema simpleType definitions.
+
+=head1 SYNOPSIS
+
+    # example simpleType derived by restriction
+    # XSD would be:
+    # <simpleType name="MySimpleType">
+    #    <restriction base="xsd:string" />
+    # </simpleType>
+    package MySimpleType;
+    use Class::Std::Storable;
+    # restriction base implemented via inheritance
+    use SOAP::WSDL::XSD::Typelib::Builtin;
+    use SOAP::WSDL::XSD::Typelib::SimpleType;
+    use base qw(
+        # derive by restriction
+        'SOAP::WSDL::XSD::Typelib::SimpleType::restriction',
+        # restriction base
+        'SOAP::WSDL::XSD::Typelib::Builtin::string'
+    );
+
+    # example simpleType derived by list.
+    # XSD would be:
+    # <simpleType name="MySimpleListType">
+    #    <list itemTipe="xsd:string" />
+    # </simpleType>
+    package MySimpleListType;
+    use Class::Std::Storable;
+    # restriction base implemented via inheritance
+    use SOAP::WSDL::XSD::Typelib::Builtin;
+    use base ('SOAP::WSDL::XSD::Typelib::SimpleType',
+        'SOAP::WSDL::XSD::Typelib::Builtin::list',        # derive by list
+        'SOAP::WSDL::XSD::Typelib::Builtin::string'       # list itemType
+    );
+
+=head1 How to write your own simple type
+
+Writing a simple type class is easy - all you have to do is setting up the
+base classes correctly.
+
+The following rules apply:
+
+=over
+
+=item * simpleType derived via list
+
+simpleType classes derived via list must inherit from these classes in
+exactly this order:
+
+ SOAP::WSDL::XSD::Typelib::SimpleType
+ SOAP::WSDL::XSD::Typelib::Builtin::list         # derive by list
+ The::List::ItemType::Class                      # list itemType
+
+The::List::ItemType::Class can either be a builtin class (see
+SOAP::WSDL::XSD::Builtin) or another simpleType class (any other class
+implementing the right methods is supported too, but not for the
+faint of heart).
+
+=item * simpleType derived via restriction
+
+simpleType classes derived via restriction must inherit from these classes in
+exactly this order:
+
+ SOAP::WSDL::XSD::Typelib::SimpleType               # you may leave out this
+ SOAP::WSDL::XSD::Typelib::SimpleType::restriction  # derive by retriction
+ The::Restriction::Base::Class                      # resytriction base
+
+The::Restriction::Base::Class can either be a builtin class (see
+SOAP::WSDL::XSD::Builtin) or another simpleType class.
+
+The slight inconsistency between the these variants is caused by the
+restriction element, which has different meanings for simpleType and
+complexType definitions.
+
+=back
+
+=head1 BUGS AND LIMITATIONS
+
+=over
+
+=item * Thread safety
+
+SOAP::WSDL::XSD::Typelib::SimpleType uses Class::Std::Storable which uses
+Class::Std. Class::Std is not thread safe, so
+SOAP::WSDL::XSD::Typelib::SimpleType is neither.
+
+=item * union
+
+union simple types are not supported yet.
+
+=item * XML Schema facets
+
+No facets are implemented yet.
+
+=back
+
+=head1 AUTHOR
+
+Replace whitespace by @ in e-mail address.
+
+ Martin Kutter E<gt>martin.kutter fen-net.deE<lt>
+
+=head1 COPYING
+
+This library is free software, you may distribute/modify it under the
+same terms as perl itself
+
+=cut
--- a/t/001_use.t
+++ b/t/001_use.t
@@ -0,0 +1,30 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More qw/no_plan/; # TODO: change to tests => N;
+use lib '../lib';
+chdir 't/' if (-d 't/');
+
+my @modules = qw(
+    SOAP::WSDL::Definitions
+    SOAP::WSDL::Message
+    SOAP::WSDL::Operation
+    SOAP::WSDL::OpMessage
+    SOAP::WSDL::SoapOperation
+    SOAP::WSDL::Binding
+    SOAP::WSDL::Port
+    SOAP::WSDL::PortType
+    SOAP::WSDL::Types
+    SOAP::WSDL::SAX::WSDLHandler
+    SOAP::WSDL::XSD::Primitive
+    SOAP::WSDL::XSD::ComplexType
+    SOAP::WSDL::XSD::SimpleType
+    SOAP::WSDL::XSD::Element
+    SOAP::WSDL::XSD::Schema
+);
+
+for my $module (@modules)
+{
+    use_ok($module);
+    ok($module->new(), "Object creation");
+}
--- a/t/002_sax.t
+++ b/t/002_sax.t
@@ -0,0 +1,334 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More tests => 18; # qw/no_plan/; # TODO: change to tests => N;
+use lib '../lib';
+use XML::SAX::ParserFactory;
+
+eval {
+    require Test::XML;
+    import Test::XML;
+};
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(
+    { base => 'XML::SAX::Base' }
+), "Object creation");
+
+my $parser = XML::SAX::ParserFactory->parser(
+        Handler => $filter
+);
+
+$parser->parse_string( xml() );
+
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+my $types = $wsdl->first_types();
+
+is $types->get_parent(), $wsdl , 'types parent';
+
+my $serializer_options = {
+    readable => 1,
+    autotype => 1,
+    namespace => { 'urn:myNamespace' => 'tns',
+        "http://www.w3.org/2001/XMLSchema" => 'xsd' },
+    typelib => $wsdl->first_types(),
+    indent => "\t",
+};
+
+my $xml;
+my $type = $types->find_type( 'urn:myNamespace', 'testSimpleType1' );
+
+
+ok($xml = $type->serialize( 'test', 1 , $serializer_options ),
+    "serialize simple Type"
+);
+
+# print $xml;
+
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, '<test type="tns:testSimpleType1">1</test>',
+        "content compare" );
+};
+
+$type = $types->find_type( 'urn:myNamespace', 'testSimpleList' );
+ok($xml = $type->serialize( 'testList', [ 1, 2, 3 ] , $serializer_options ),
+    "serialize simple list type"
+);
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, '<testList type="tns:testSimpleList">1 2 3</testList>',
+        "content compare" );
+};
+
+$type = $types->find_element( 'urn:myNamespace', 'TestElement' );
+
+ok($xml = $type->serialize( undef, 1 , $serializer_options ),
+    "serialize simple element");
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, '<TestElement type="xsd:int">1</TestElement>',
+        "content compare" );
+};
+
+ok( $xml = $types->find_type( 'urn:myNamespace', 'length3')->serialize(
+        'TestComplex', { size => -13, unit => 'BLA' } ,
+        $serializer_options
+    ),
+    "serialize complex type");
+
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, q{
+        <TestComplex type="tns:length3">
+           <size type="xsd:non-positive-integer">-13</size>
+           <unit type="xsd:NMTOKEN">BLA</unit>
+        </TestComplex>},
+        "content compare" );
+};
+
+ok($xml = $types->find_element( 'urn:myNamespace', 'TestElementComplexType')
+    ->serialize(
+        undef, { size => -13, unit => 'BLA' } , $serializer_options ),
+        "serialize element with complex type"
+);
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, q{
+        <TestElementComplexType type="tns:length3">
+                <size type="xsd:non-positive-integer">-13</size>
+                <unit type="xsd:NMTOKEN">BLA</unit>
+        </TestElementComplexType>
+    },
+    "content compare" );
+};
+
+
+ok($xml = $types->find_type( 'urn:myNamespace', 'complex')->serialize(
+        'complexComplex',
+        { 'length' => {  size => -13, unit => 'BLA' }, 'int' => 1 },
+        $serializer_options ),
+        "serialize complex type with complex content"
+);
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, q{
+        <complexComplex type="tns:complex">
+                <length type="tns:length3">
+                        <size type="xsd:non-positive-integer">-13</size>
+                        <unit type="xsd:NMTOKEN">BLA</unit>
+                </length>
+                <int type="xsd:int">1</int>
+        </complexComplex>
+        },
+        "content compare" );
+}
+ok($xml = $wsdl->find_message('urn:myNamespace', 'testRequest')
+        ->get_part()->[0]->serialize(
+        undef, 
+        { test => { length => {  size => -13, unit => 'BLA' } , int => 3 } },
+    $serializer_options ),
+    "serialize part"
+);
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $xml, q{
+        <test type="tns:complex">
+                <length type="tns:length3">
+                        <size type="xsd:non-positive-integer">-13</size>
+                        <unit type="xsd:NMTOKEN">BLA</unit>
+                </length>
+                <int type="xsd:int">3</int>
+        </test>
+    },
+    "content compare")
+};
+
+my $opt = {
+        typelib => $types,
+        readable => 1,
+        autotype => 0,
+        namespace => { 'urn:myNamespace' => 'tns',
+                'http://www.w3.org/2001/XMLSchema' => 'xsd',
+                'http://schemas.xmlsoap.org/wsdl/' => 'wsdl',
+        },
+        indent => "",
+        wsdl => $wsdl,
+};
+
+# ok $wsdl->explain($opt) =~ m/#optional/m;
+
+sub skip_without_test_xml {
+    skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
+}
+
+sub xml
+{
+        return q{<?xml version="1.0"?>
+<definitions name="simpleType"
+        targetNamespace="urn:myNamespace"
+        xmlns="http://schemas.xmlsoap.org/wsdl/"
+        xmlns:tns="urn:myNamespace"
+        xmlns:xsd="http://www.w3c.org/2001/XMLSchema"
+        xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+>
+        <types>
+                <xsd:schema targetNamespace="urn:myNamespace">
+                <xsd:complexType name="length3">
+                         <xsd:all>
+                                  <xsd:element name="size" type="xsd:non-positive-integer"/>
+                                  <xsd:element name="unit" type="xsd:NMTOKEN"/>
+                         </xsd:all>
+                </xsd:complexType>
+
+                <xsd:complexType name="complex">
+                        <xsd:sequence>
+                                  <xsd:element name="length" type="tns:length3"/>
+                                  <xsd:element name="int" type="xsd:int"/>
+                         </xsd:sequence>
+                </xsd:complexType>
+
+                <xsd:element name="TestElement" type="xsd:int"/>
+                <xsd:element name="TestElementComplexType" type="tns:length3"/>
+                <xsd:simpleType name="testSimpleType1">
+                        <xsd:restriction base="int">
+                                <xsd:enumeration value="1"/>
+                                <xsd:enumeration value="2"/>
+                                <xsd:enumeration value="3"/>
+                        </xsd:restriction>
+                </xsd:simpleType>
+
+                <xsd:simpleType name="testSimpleList">
+                        <xsd:annotation>
+                                <xsd:documentation>
+                                SimpleType Test
+                                </xsd:documentation>
+                        </xsd:annotation>
+                        <xsd:list itemType="int">
+                        </xsd:list>
+                </xsd:simpleType>
+                <xsd:simpleType name="testSimpleUnion">
+                        <xsd:annotation>
+                                <xsd:documentation>
+                                SimpleType Union test
+                                </xsd:documentation>
+                        </xsd:annotation>
+                        <xsd:union memberTypes="int float">
+                        </xsd:union>
+                </xsd:simpleType>
+                </xsd:schema>
+        </types>
+        <message name="testRequest">
+                <part name="test" type="tns:complex"/>
+        </message>
+        <message name="testResponse">
+                <part name="test" type="tns:testSimpleType1"/>
+        </message>
+        <message name="testRequest2">
+                <part name="test" type="tns:testSimpleType1"/>
+        </message>
+        <message name="testResponse2">
+                <part name="test" type="tns:testSimpleType1"/>
+        </message>
+        <portType name="testPort">
+                <operation name="test">
+                        <documentation>
+                                Test-Methode
+                        </documentation>
+
+                        <input message="tns:testRequest"/>
+                        <output message="tns:testResponse"/>
+                </operation>
+                <operation name="test2">
+                        <documentation>
+                                Test-Methode
+                        </documentation>
+
+                        <input message="tns:testRequest2"/>
+                        <output message="tns:testResponse2"/>
+                </operation>
+        </portType>
+        <portType name="testPort2">
+                <operation name="test">
+                        <documentation>
+                                Test-Methode
+                        </documentation>
+
+                        <input message="tns:testRequest"/>
+                        <output message="tns:testResponse"/>
+                </operation>
+        </portType>
+        <portType name="testPort3">
+                <operation name="test">
+                        <documentation>
+                                Test-Methode
+                        </documentation>
+                        <input message="tns:testRequest"/>
+                        <output message="tns:testResponse"/>
+                </operation>
+        </portType>
+
+        <binding type="tns:testPort" name="testBinding">
+        <operation name="test">
+                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+                <soap:operation soapAction="test">
+                        <input>
+                                <soap:body use="literal"/>
+                        </input>
+                        <output>
+                                <soap:body use="literal"/>
+                        </output>
+                </soap:operation>
+        </operation>
+        </binding>
+        <binding type="tns:testPort2" name="testBinding2">
+                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+        <operation name="test">
+                <soap:operation soapAction="test">
+                        <input>
+                                <soap:body use="literal"/>
+                        </input>
+                        <output>
+                                <soap:body use="literal"/>
+                        </output>
+                </soap:operation>
+        </operation>
+        </binding>
+        <binding type="tns:testPort3" name="testBinding3">
+                <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+        <operation name="test">
+                <soap:operation soapAction="test">
+                        <input>
+                                <soap:body use="literal"/>
+                        </input>
+                        <output>
+                                <soap:body use="literal"/>
+                        </output>
+                </soap:operation>
+        </operation>
+        </binding>
+        <service name="testService">
+                <port name="testPort" binding="tns:testBinding">
+                        <soap:address location="http://127.0.0.1/testPort" />
+                </port>
+                <port name="testPort2" binding="tns:testBinding2">
+                        <soap:address location="http://127.0.0.1/testPort2" />
+                </port>
+        </service>
+        <service name="testService2">
+                <port name="testPort3" binding="tns:testBinding3">
+                        <soap:address location="http://127.0.0.1/testPort3" />
+                </port>
+
+        </service>
+</definitions>
+};
+
+}
+
--- a/t/003_sax_serializer.t
+++ b/t/003_sax_serializer.t
@@ -0,0 +1,287 @@
+use Test::More tests => 11;
+use Data::Dumper;
+use lib '../lib';
+use XML::LibXML;
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
+
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+eval { $parser->parse_string( xml() ) };
+if ($@)
+{
+	fail("parsing WSDL");
+	die "Can't test without parsed WSDL";
+}
+else
+{
+	pass("parsing XML");
+}
+
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+
+my $schema = $wsdl->first_types();
+
+my $opt = {
+	readable => 0,
+	autotype => 1,
+    namespace => $wsdl->get_xmlns(),
+	indent => "\t",
+	typelib => $schema,
+};
+
+is( $schema->find_type( 'myNamespace', 'testSimpleType1' )->serialize(
+	'test', 1 , $opt ),
+	q{<test type="tns:testSimpleType1">1</test>} , "serialize simple type");
+
+is( $schema->find_type( 'myNamespace', 'testSimpleList' )->serialize(
+	'testList', [ 1, 2, 3 ] , $opt),
+	q{<testList type="tns:testSimpleList">1 2 3</testList>},
+	"serialize simple list type"
+);
+
+is( $schema->find_element( 'myNamespace', 'TestElement' )->serialize(
+	undef, 1 , $opt),
+	q{<TestElement type="xsd:int">1</TestElement>}, "Serialize element"
+);
+
+$opt->{ readable } = 0;
+
+is( $schema->find_type( 'myNamespace', 'length3')->serialize(
+	'TestComplex', { size => -13, unit => 'BLA' } ,
+	$opt ),
+	q{<TestComplex type="tns:length3" >}
+	. q{<size type="xsd:non-positive-integer">-13</size>}
+	. q{<unit type="xsd:NMTOKEN">BLA</unit></TestComplex>}
+	, "serialize complex type" );
+
+is( $schema->find_element( 'myNamespace', 'TestElementComplexType')->serialize(
+	undef, { size => -13, unit => 'BLA' } ,
+	$opt ),
+	q{<TestElementComplexType type="tns:length3" >}
+	. q{<size type="xsd:non-positive-integer">-13</size>}
+	. q{<unit type="xsd:NMTOKEN">BLA</unit></TestElementComplexType>},
+	"element with complex type"
+);
+
+is( $schema->find_type( 'myNamespace', 'complex')->serialize(
+	'complexComplex',
+	{ 'length' => {  size => -13, unit => 'BLA' }, 'int' => 1 },
+	$opt ),
+	q{<complexComplex type="tns:complex" >}
+	. q{<length type="tns:length3" >}
+	. q{<size type="xsd:non-positive-integer">-13</size>}
+	. q{<unit type="xsd:NMTOKEN">BLA</unit></length>}
+	. q{<int type="xsd:int">1</int></complexComplex>},
+	"nested complex type"
+);
+
+is( $wsdl->find_message('myNamespace', 'testRequest')->first_part()->serialize(
+	undef, { test => { length => {  size => -13, unit => 'BLA' } , int => 3 } },
+	$opt ),
+	q{<test type="tns:complex" >}
+	. q{<length type="tns:length3" >}
+	. q{<size type="xsd:non-positive-integer">-13</size>}
+	. q{<unit type="xsd:NMTOKEN">BLA</unit>}
+	. q{</length><int type="xsd:int">3</int></test>}
+	, "Message part"
+);
+
+
+exit;
+
+foreach my $service (@{ $wsdl->service() })
+{
+	print "Service: ", $service->name(), "\n";
+
+	foreach my $port( @{ $service->port() })
+	{
+		print "  ", "port name: ", $port->name, "\n";
+		print "    ", "binding: ", $port->binding(), "\n";
+		print "    ", "location: ", $port->location,"\n";
+		my $portType = $wsdl->get_portType(
+			$wsdl->get_binding( $port->binding() )->type()
+		);
+		foreach my $operation ( @{ $portType->operation() } )
+		{
+			print "      ", "Operation name: ", $operation->name(), "\n";
+			print "        ", "Input message: ",
+				$operation->input()->message(), "\n"
+					if ($operation->input());
+			my $input = $wsdl->get_message( $operation->input()->message() );
+			print "          ", "Type: ", $input->name(), "\n";
+
+			print "        ", "Output message: ",
+				$operation->output()->message(), "\n"
+					if ($operation->output());
+			my $output = $wsdl->get_message( $operation->output()->message() );
+			print "          ", "Type: ", $output->name(), "\n";
+		}
+	}
+}
+
+
+sub xml
+{
+	return q{<?xml version="1.0"?>
+<definitions name="simpleType"
+	targetNamespace="myNamespace"
+	xmlns="http://schemas.xmlsoap.org/wsdl/"
+	xmlns:tns="myNamespace"
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+	xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+	xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+>
+	<types>
+		<xsd:schema targetNamespace="myNamespace">
+		<xsd:complexType name="length3">
+ 			<xsd:sequence>
+  				<xsd:element name="size" type="xsd:non-positive-integer"/>
+  				<xsd:element name="unit" type="xsd:NMTOKEN"/>
+ 			</xsd:sequence>
+		</xsd:complexType>
+
+		<xsd:complexType name="complex">
+			<xsd:sequence>
+  				<xsd:element name="length" type="tns:length3"/>
+  				<xsd:element name="int" type="xsd:int"/>
+ 			</xsd:sequence>
+		</xsd:complexType>
+
+		<xsd:element name="TestElement" type="xsd:int"/>
+		<xsd:element name="TestElementComplexType" type="tns:length3"/>
+		<xsd:simpleType name="testSimpleType1">
+			<xsd:restriction base="int">
+				<xsd:enumeration value="1"/>
+				<xsd:enumeration value="2"/>
+				<xsd:enumeration value="3"/>
+			</xsd:restriction>
+		</xsd:simpleType>
+
+		<xsd:simpleType name="testSimpleList">
+			<xsd:annotation>
+				<xsd:documentation>
+				SimpleType Test
+				</xsd:documentation>
+			</xsd:annotation>
+			<xsd:list itemType="int">
+			</xsd:list>
+		</xsd:simpleType>
+		<xsd:simpleType name="testSimpleUnion">
+			<xsd:annotation>
+				<xsd:documentation>
+				SimpleType Union test
+				</xsd:documentation>
+			</xsd:annotation>
+			<xsd:union memberTypes="int float">
+			</xsd:union>
+		</xsd:simpleType>
+		</xsd:schema>
+	</types>
+	<message name="testRequest">
+		<part name="test" type="tns:complex"/>
+	</message>
+	<message name="testResponse">
+		<part name="test" type="tns:testSimpleType1"/>
+	</message>
+	<message name="testRequest2">
+		<part name="test" type="tns:testSimpleType1"/>
+	</message>
+	<message name="testResponse2">
+		<part name="test" type="tns:testSimpleType1"/>
+	</message>
+	<portType name="testPort">
+		<operation name="test">
+			<documentation>
+				Test-Methode
+			</documentation>
+
+			<input message="testRequest"/>
+			<output message="testResponse"/>
+		</operation>
+		<operation name="test2">
+			<documentation>
+				Test-Methode
+			</documentation>
+
+			<input message="testRequest2"/>
+			<output message="testResponse2"/>
+		</operation>
+	</portType>
+	<portType name="testPort2">
+		<operation name="test">
+			<documentation>
+				Test-Methode
+			</documentation>
+
+			<input message="testRequest"/>
+			<output message="testResponse"/>
+		</operation>
+	</portType>
+	<portType name="testPort3">
+		<operation name="test">
+			<documentation>
+				Test-Methode
+			</documentation>
+			<input message="testRequest"/>
+			<output message="testResponse"/>
+		</operation>
+	</portType>
+
+	<binding type="testPort" name="testBinding">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+		<soap:operation soapAction="test">
+			<input>
+				<soap:body use="literal"/>
+			</input>
+			<output>
+				<soap:body use="literal"/>
+			</output>
+		</soap:operation>
+	</binding>
+	<binding type="testPort2" name="testBinding2">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+		<soap:operation soapAction="test">
+			<input>
+				<soap:body use="literal"/>
+			</input>
+			<output>
+				<soap:body use="literal"/>
+			</output>
+		</soap:operation>
+	</binding>
+	<binding type="testPort3" name="testBinding3">
+		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+		<soap:operation soapAction="test">
+			<input>
+				<soap:body use="literal"/>
+			</input>
+			<output>
+				<soap:body use="literal"/>
+			</output>
+		</soap:operation>
+	</binding>
+	<service name="testService">
+		<port name="testPort" binding="testBinding">
+			<soap:address location="http://127.0.0.1/testPort" />
+		</port>
+		<port name="testPort2" binding="testBinding2">
+			<soap:address location="http://127.0.0.1/testPort2" />
+		</port>
+		<port name="testPort3" binding="testBinding3">
+			<soap:address location="http://127.0.0.1/testPort3" />
+		</port>
+
+	</service>
+</definitions>
+};
+
+}
+
--- a/t/004_sax_wsdl.t
+++ b/t/004_sax_wsdl.t
@@ -0,0 +1,405 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More tests => 5;
+use lib '../lib';
+use XML::SAX::ParserFactory;
+
+use diagnostics;
+
+eval {
+    require Test::XML;
+    import Test::XML;
+};
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
+
+use XML::LibXML;
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+eval { $parser->parse_string( xml() ) };
+if ($@)
+{
+	fail("parsing WSDL");
+	die "Can't test without parsed WSDL: $@";
+}
+else
+{
+	pass("parsing XML");
+}
+
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+my $schema = $wsdl->get_types()->[0]->get_schema()->[0] || die "No schema !";
+
+my $opt = {
+	typelib => $wsdl->first_types,
+	readable => 1,
+	autotype => 0,
+	namespace => { 'http://www.example.org/MessageGateway2/' => 'tns',
+		'http://www.w3.org/2001/XMLSchema' => 'xsd',
+		'http://schemas.xmlsoap.org/wsdl/' => 'wsdl',
+	},
+	indent => "",
+};
+
+my $data = { EnqueueMessage => {
+	MMessage => {
+		MRecipientURI => 'anyURI',
+		MSenderAddress => 'a string',
+		MMessageContent => 'a string',
+		MSubject => 'a string',
+		MDeliveryReportRecipientURI => 'anyURI',
+		MKeepalive => {
+			MKeepaliveTimeout => 1234567,
+			MKeepaliveErrorPolicy => ' ( suppress | report ) ',
+		}
+	}
+}
+
+};
+ 
+
+SKIP: { skip_without_test_xml();
+    is_xml( $wsdl->find_message(
+        "http://www.example.org/MessageGateway2/" ,'EnqueueMessageRequest'
+        )->first_part()->serialize( 'test', $data, $opt ),
+        xml_message()
+        , "Serialized message part"
+    );
+}
+
+sub skip_without_test_xml {
+    skip("Test::XML not available", 1) if (not $Test::XML::VERSION);
+}
+
+sub xml_message {
+	return
+q{<EnqueueMessage xmlns="http://www.example.org/MessageGateway2/">
+	<MMessage>
+		<MRecipientURI>anyURI</MRecipientURI>
+		<MSenderAddress>a string</MSenderAddress>
+		<MMessageContent>a string</MMessageContent>
+		<MSubject>a string</MSubject>
+		<MDeliveryReportRecipientURI>anyURI</MDeliveryReportRecipientURI>
+		<MKeepalive>
+			<MKeepaliveTimeout>1234567</MKeepaliveTimeout>
+			<MKeepaliveErrorPolicy> ( suppress | report ) </MKeepaliveErrorPolicy>
+		</MKeepalive>
+	</MMessage>
+</EnqueueMessage>
+};
+
+}
+
+sub xml {
+	return q{<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions name="MessageGateway"
+  targetNamespace="http://www.example.org/MessageGateway2/"
+  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:tns="http://www.example.org/MessageGateway2/"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
+  <wsdl:types>
+    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+      targetNamespace="http://www.example.org/MessageGateway2/">
+
+      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage"
+        xmlns:tns="http://www.example.org/MessageGateway2/">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+      <xsd:complexType name="TMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A type containing all elements of a message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
+                phone:. Not all URI schemas need to be implemented at the current
+                implementation stage.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                E-Mail sender address. Ignored for all but mailto: recipient URIs.
+              </xsd:documentation>
+
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>Message Content.</xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
+
+            <xsd:annotation>
+              <xsd:documentation>
+                Message Subject. Ignored for all but mailto: URIs
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+
+                URI to send a delivery report to. May be of one of the following schemes:
+                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
+                reports to http(s) URIs are sent as SOAP requests following the
+                MessageGatewayClient service definition.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                Container for keepalive information. May be missing.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepalive">
+        <xsd:annotation>
+          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+
+          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
+            <xsd:annotation>
+              <xsd:documentation>
+                Keepalive timeout. The keepalive timeout spezifies how long the sending of
+                a message will be delayed waiting for keepalive updates. If a keepalive
+                update is received during this period, the timeout will be reset. If not,
+                the message will be sent after the timeout has expired.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                Policy to comply to in case of system errors. Valid values are "suppress"
+                and "report". If the policy is set to "suppress", keepalive messages will
+                not be sent to their recipients in case of partial system failure, even if
+                the keepalive has expired. This may result in "false negatives", i.e.
+                messages may not be sent, even though their keepalive has expired. If the
+                value is "report", keepalive messages will be sent from any cluster node.
+                This may result in "false positive" alerts.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="suppress"></xsd:enumeration>
+                <xsd:enumeration value="report"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Type containing a message ID.</xsd:documentation>
+        </xsd:annotation>
+
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepliveMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            Type containing all elements of a keppalive update / remove request.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The ID for the message to update / remove
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The action to perform. Valid values are: "remove", "update". On "remove",
+                the message with the ID specified will be removed from the queue, thus it
+                will never be sent, even if it's timeout expires. On "update" the
+                keepalive timeout of the corresponding message will be reset.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="remove"></xsd:enumeration>
+                <xsd:enumeration value="update"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>Keepalive message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message response element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+
+      <xsd:complexType name="TEnqueueMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessage" type="tns:TMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a message to enqueue.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+
+      <xsd:complexType name="TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The keepalive message to process.
+          </xsd:documentation>
+
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a keepalive message to process.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+        </xsd:sequence>
+      </xsd:complexType>
+    </xsd:schema>
+  </wsdl:types>
+  <wsdl:message name="EnqueueMessageRequest">
+    <wsdl:part name="parameters" element="tns:EnqueueMessage">
+      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+
+  </wsdl:message>
+  <wsdl:message name="EnqueueMessageResponse">
+    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
+      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageRequest">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
+
+      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageResponse">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
+      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+
+  <wsdl:portType name="MGWPortType">
+    <wsdl:documentation>
+      generic port type for all methods required for sending messages over the mosaic
+      message gatewa
+    </wsdl:documentation>
+    <wsdl:operation name="EnqueueMessage">
+      <wsdl:documentation>
+        This method is used to enqueue a normal (immediate send) or a delayed message with
+        keepalive functionality.
+      </wsdl:documentation>
+      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
+
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <wsdl:documentation>
+        This method is used to update or remove a
+        keepalive message.
+      </wsdl:documentation>
+      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
+    </wsdl:operation>
+  </wsdl:portType>
+
+  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
+    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
+    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="EnqueueMessage">
+      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <soap:operation
+        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:service name="MessageGateway">
+    <wsdl:documentation>
+      Web Service for sending messages over the mosaic message gatewa
+    </wsdl:documentation>
+
+    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
+      <wsdl:documentation>HTTP(S) port for the mosaic message gatewa</wsdl:documentation>
+      <soap:address location="https://www.example.org/MessageGateway/" />
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>};
+}
--- a/t/005_sax_contributed_wsdl.t
+++ b/t/005_sax_contributed_wsdl.t
@@ -0,0 +1,255 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More qw/no_plan/; # TODO: change to tests => N;
+use Data::Dumper;
+use lib '../lib';
+use XML::LibXML;
+
+use diagnostics;
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
+
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+eval { $parser->parse_string( xml() ) };
+if ($@)
+{
+	fail("parsing WSDL");
+	die "Can't test without parsed WSDL: $@";
+}
+else
+{
+	pass("parsing XML");
+}
+
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+my $opt = {
+	namespace => $wsdl->get_xmlns(),
+	style => 'perl',
+	wsdl => $wsdl,
+	readable => 1,
+};
+
+my $txt;
+ok( $txt = $wsdl->explain( $opt ) , "explain WSDL" );
+
+# print $txt;
+
+sub xml {
+	return q{<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions targetNamespace="http://example.com/soap/services/ETest/impl"
+  xmlns="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:apachesoap="http://xml.apache.org/xml-soap"
+  xmlns:impl="http://example.com/soap/services/ETest/impl"
+  xmlns:intf="http://example.com/soap/services/ETest"
+  xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
+  xmlns:tns1="urn:ETest"
+  xmlns:tns2="urn:acquisition"
+  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+
+  <wsdl:types>
+    <schema targetNamespace="urn:ETest" xmlns="http://www.w3.org/2001/XMLSchema">
+      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
+      <complexType name="CreationBaseData">
+        <sequence>
+          <element name="createdBy" nillable="true" type="xsd:long" />
+          <element name="creationDate" nillable="true" type="xsd:dateTime" />
+          <element name="updateDateCenter" nillable="true" type="xsd:dateTime" />
+          <element name="updateDateLocal" nillable="true" type="xsd:dateTime" />
+          <element name="updatedBy" nillable="true" type="xsd:long" />
+        </sequence>
+      </complexType>
+      <complexType name="CreationData">
+        <complexContent>
+          <extension base="tns1:CreationBaseData">
+            <sequence>
+              <element name="creatorFullName" nillable="true" type="xsd:string" />
+              <element name="modifierFullName" nillable="true" type="xsd:string" />
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+      <complexType abstract="true" name="EProductData">
+        <sequence>
+          <element name="EStatus" nillable="true" type="xsd:string" />
+          <element name="EStatusUpdatedate" nillable="true" type="xsd:dateTime" />
+          <element name="SFXID" nillable="true" type="xsd:string" />
+          <element name="activationFromDate" nillable="true" type="xsd:dateTime" />
+          <element name="activationToDate" nillable="true" type="xsd:dateTime" />
+          <element name="activityStatusDateFrom" nillable="true" type="xsd:dateTime" />
+          <element name="activityStatusDateTo" nillable="true" type="xsd:dateTime" />
+          <element name="canEditSFXID" type="xsd:boolean" />
+          <element name="concurrentNumberOfUsers" nillable="true" type="xsd:int" />
+          <element name="creationData" nillable="true" type="tns1:CreationData" />
+          <element name="deleteable" type="xsd:boolean" />
+          <element name="ETestCode" nillable="true" type="xsd:string" />
+          <element name="id" nillable="true" type="xsd:long" />
+          <element name="instanceCode" nillable="true" type="xsd:string" />
+          <element name="mainContact" nillable="true" type="xsd:string" />
+          <element name="metaLibID" nillable="true" type="xsd:string" />
+          <element name="otherID" nillable="true" type="xsd:string" />
+          <element name="otherSource" nillable="true" type="xsd:string" />
+          <element name="privateNote" nillable="true" type="xsd:string" />
+          <element name="procurementStatus" nillable="true" type="xsd:string" />
+          <element name="procurementStatusUpdateDate" nillable="true" type="xsd:dateTime" />
+          <element name="procurementStatusUpdatedate" nillable="true" type="xsd:dateTime" />
+          <element name="sourceInstanceCode" nillable="true" type="xsd:string" />
+          <element name="sponseringLibraryCode" nillable="true" type="xsd:string" />
+          <element name="sponseringLibraryName" nillable="true" type="xsd:string" />
+          <element name="updateTarget" nillable="true" type="xsd:string" />
+          <element name="workExpressionCode" nillable="true" type="xsd:string" />
+        </sequence>
+      </complexType>
+      <complexType name="EProductInformation">
+        <sequence>
+          <element name="acquisitions" nillable="true"
+            type="impl:ArrayOf_tns2_AcquisitionData" />
+          <element name="data" nillable="true" type="tns1:EProductData" />
+        </sequence>
+      </complexType>
+    </schema>
+    <schema targetNamespace="urn:acquisition" xmlns="http://www.w3.org/2001/XMLSchema">
+      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
+      <complexType name="AcquisitionCommonData">
+        <sequence>
+          <element name="budgets" nillable="true" type="xsd:string" />
+          <element name="campusCode" nillable="true" type="xsd:string" />
+          <element name="concurrentUsersNote" nillable="true" type="xsd:string" />
+          <element name="creationData" nillable="true" type="tns1:CreationData" />
+          <element name="id" nillable="true" type="xsd:long" />
+          <element name="instituteCode" nillable="true" type="xsd:string" />
+        </sequence>
+      </complexType>
+      <complexType name="AcquisitionData">
+        <sequence>
+          <element name="ILSSubscriptionNo" nillable="true" type="xsd:string" />
+          <element name="acquisitionCode" nillable="true" type="xsd:string" />
+          <element name="acquisitionCommonData" nillable="true"
+            type="tns2:AcquisitionCommonData" />
+          <element name="acquisitionMethod" nillable="true" type="xsd:string" />
+          <element name="acquisitionNumber" nillable="true" type="xsd:string" />
+          <element name="acquisitionStatus" nillable="true" type="xsd:string" />
+          <element name="acquisitionStatusDate" nillable="true" type="xsd:dateTime" />
+          <element name="advanceNoticeDate" nillable="true" type="xsd:dateTime" />
+          <element name="autoRenewal" nillable="true" type="xsd:boolean" />
+          <element name="consortialAgreement" type="xsd:boolean" />
+          <element name="discountOnPrice" nillable="true" type="xsd:int" />
+          <element name="id" nillable="true" type="xsd:long" />
+          <element name="instanceCode" nillable="true" type="xsd:string" />
+          <element name="materialType" nillable="true" type="xsd:string" />
+          <element name="noteForILS" nillable="true" type="xsd:string" />
+          <element name="noteForVendor" nillable="true" type="xsd:string" />
+          <element name="noticePeriodCode" nillable="true" type="xsd:string" />
+          <element name="numberOfCopies" nillable="true" type="xsd:int" />
+          <element name="orderDate" nillable="true" type="xsd:dateTime" />
+          <element name="orderForm" nillable="true" type="xsd:string" />
+          <element name="orderSendMethod" nillable="true" type="xsd:string" />
+          <element name="pooledConcurrentUsers" nillable="true" type="xsd:int" />
+          <element name="price" nillable="true" type="xsd:double" />
+          <element name="pricingCap" nillable="true" type="xsd:int" />
+          <element name="pricingCapFrom" nillable="true" type="xsd:dateTime" />
+          <element name="pricingCapTo" nillable="true" type="xsd:dateTime" />
+          <element name="pricingModel" nillable="true" type="xsd:string" />
+          <element name="printCancellationNote" nillable="true" type="xsd:string" />
+          <element name="printCancellationRestriction" type="xsd:boolean" />
+          <element name="printPurchaseOrderNo" nillable="true" type="xsd:string" />
+          <element name="purchaseOrderNo" nillable="true" type="xsd:string" />
+          <element name="renewallOrCancellationDate" nillable="true" type="xsd:dateTime" />
+          <element name="renewallOrCancellationDescisionNote" nillable="true"
+            type="xsd:string" />
+          <element name="renewallOrCancellationNoteForILS" nillable="true"
+            type="xsd:string" />
+          <element name="renewallOrCancellationNoteForVendor" nillable="true"
+            type="xsd:string" />
+          <element name="subscriptionNotification" nillable="true" type="xsd:int" />
+          <element name="subscriptionPeriodCode" nillable="true" type="xsd:string" />
+          <element name="subscriptionType" nillable="true" type="xsd:string" />
+          <element name="subscriptionTypeNote" nillable="true" type="xsd:string" />
+          <element name="vendorAdvancedNotice" nillable="true" type="xsd:int" />
+          <element name="vendorAdvancedNoticeVal" nillable="true" type="xsd:string" />
+          <element name="vendorCode" nillable="true" type="xsd:string" />
+          <element name="vendorName" nillable="true" type="xsd:string" />
+          <element name="vendorSubscriptionCode" nillable="true" type="xsd:string" />
+        </sequence>
+      </complexType>
+    </schema>
+    <schema targetNamespace="http://example.com/soap/services/ETest/impl"
+      xmlns="http://www.w3.org/2001/XMLSchema">
+      <import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
+      <complexType name="ArrayOf_tns2_AcquisitionData">
+        <complexContent>
+          <restriction base="soapenc:Array">
+            <attribute ref="soapenc:arrayType" wsdl:arrayType="tns2:AcquisitionData[]" />
+          </restriction>
+        </complexContent>
+      </complexType>
+    </schema>
+  </wsdl:types>
+  <wsdl:message name="getETestResponse">
+    <wsdl:part name="getETestReturn" type="tns1:EProductInformation" />
+  </wsdl:message>
+  <wsdl:message name="getFixedETestResponse">
+    <wsdl:part name="getFixedETestReturn" type="tns1:EProductInformation" />
+  </wsdl:message>
+  <wsdl:message name="getFixedETestRequest"></wsdl:message>
+  <wsdl:message name="getETestRequest">
+    <wsdl:part name="indexName" type="xsd:string" />
+    <wsdl:part name="indexValue" type="xsd:string" />
+    <wsdl:part name="withStatus" type="xsd:string" />
+  </wsdl:message>
+  <wsdl:portType name="ETestWeb">
+    <wsdl:operation name="getETest" parameterOrder="indexName indexValue withStatus">
+      <wsdl:input message="impl:getETestRequest" name="getETestRequest" />
+      <wsdl:output message="impl:getETestResponse" name="getETestResponse" />
+    </wsdl:operation>
+    <wsdl:operation name="getFixedETest">
+      <wsdl:input message="impl:getFixedETestRequest" name="getFixedETestRequest" />
+      <wsdl:output message="impl:getFixedETestResponse"
+        name="getFixedETestResponse" />
+    </wsdl:operation>
+  </wsdl:portType>
+
+  <wsdl:binding name="ETestSoapBinding" type="impl:ETestWeb">
+    <wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="getETest">
+      <wsdlsoap:operation soapAction="" />
+      <wsdl:input name="getETestRequest">
+        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="http://example.com/soap/services/ETest" use="encoded" />
+      </wsdl:input>
+      <wsdl:output name="getETestResponse">
+        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="http://example.com/soap/services/ETest" use="encoded" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="getFixedETest">
+      <wsdlsoap:operation soapAction="" />
+      <wsdl:input name="getFixedETestRequest">
+        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="http://example.com/soap/services/ETest" use="encoded" />
+      </wsdl:input>
+      <wsdl:output name="getFixedETestResponse">
+        <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+          namespace="http://example.com/soap/services/ETest" use="encoded" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+
+  <wsdl:service name="ETestWebService">
+    <wsdl:port binding="impl:ETestSoapBinding" name="ETest">
+      <wsdlsoap:address location="http://example.com/soap/services/ETest" />
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>
+};
+}
--- a/t/006_client.t
+++ b/t/006_client.t
@@ -0,0 +1,69 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Pod::Simple::Text;
+use Test::More qw/no_plan/; # TODO: change to tests => N;
+use lib '../lib';
+use XML::SAX::ParserFactory;
+
+eval {
+    require Test::XML;
+    import Test::XML
+};
+
+use diagnostics;
+
+use Cwd;
+
+my $path = cwd;
+$path =~s|\/t\/?$||;      # allow running from t/ and above (Build test)
+
+use_ok(qw/SOAP::WSDL/);
+
+my $soap = SOAP::WSDL->new(
+    wsdl => 'file:///' . $path .'/t/acceptance/wsdl/006_sax_client.wsdl',
+    readable => 1,
+)->wsdlinit();
+
+$soap->servicename('MessageGateway');
+
+ok( $soap->no_dispatch( 1 ) , "Set no_dispatch" );
+ok( $soap->explain() );
+
+
+my $pod = Pod::Simple::Text->new();
+my $output;
+$pod->output_string( \$output );
+$pod->parse_string_document( $soap->explain() );
+
+# print $output;
+
+SKIP: {
+    skip_without_test_xml();
+    is_xml( $soap->call( 'EnqueueMessage' , EnqueueMessage => {
+            'MMessage' => {
+                     'MRecipientURI' => 'mailto:test@example.com' ,
+                     'MMessageContent' => 'TestContent for Message' ,
+            }
+        }
+    )
+    , q{<SOAP-ENV:Envelope
+        xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+        xmlns:tns="http://www.example.org/MessageGateway2/"
+        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+        xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body ><EnqueueMessage xmlns="http://www.example.org/MessageGateway2/"><MMessage>
+                <MRecipientURI>mailto:test@example.com</MRecipientURI>
+                <MMessageContent>TestContent for Message</MMessageContent>
+    </MMessage></EnqueueMessage></SOAP-ENV:Body></SOAP-ENV:Envelope>}
+    , "content comparison with optional elements");
+}
+
+sub skip_without_test_xml {
+    my $number = shift || 1;
+    skip("Test::XML not available", $number) if (not $Test::XML::VERSION);
+}
+
+__END__
+
--- a/t/007_envelope.t
+++ b/t/007_envelope.t
@@ -0,0 +1,36 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+use Test::More qw/no_plan/;
+use lib '../lib';
+
+eval {
+    require Test::XML;
+    import Test::XML;
+};
+
+use_ok qw/SOAP::WSDL::Envelope/;
+
+my $opt = {
+    readable => 1,
+    namespace => {
+    },
+};
+my $xml;
+ok( $xml = SOAP::WSDL::Envelope->serialize(
+    undef, undef, $opt
+    ),
+    "serialize empty envelope"
+);
+
+SKIP: {
+    skip 'Cannot test XML content without Test::XML', 1
+        if (not $Test::XML::VERSION);
+    is_xml( $xml, q{<SOAP-ENV:Envelope
+        xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+<SOAP-ENV:Body >
+</SOAP-ENV:Body>
+</SOAP-ENV:Envelope>}
+        , 'Content comparison' );
+}
--- a/t/008_client_wsdl_complexType.t
+++ b/t/008_client_wsdl_complexType.t
@@ -0,0 +1,30 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More qw/no_plan/; # TODO: change to tests => N;
+use lib '../lib';
+
+use Cwd;
+
+my $path = cwd;
+$path =~s|\/t\/?$||;      # allow running from t/ and above (Build test)
+
+use_ok(qw/SOAP::WSDL/);
+
+my $soap = SOAP::WSDL->new(
+    wsdl => 'file:///' . $path .'/t/acceptance/wsdl/008_complexType.wsdl'
+)->wsdlinit();
+
+my $wsdl = $soap->{ _WSDL }->{ wsdl_definitions };
+my $schema = $wsdl->first_types();
+my $type = $schema->find_type('Test' , 'testComplexTypeAll');
+my $element = $type->get_element()->[0];
+
+is $element->get_minOccurs() , 0, "minOccurs default for all";
+is $element->get_maxOccurs() , 1, "maxOccurs default for all";
+
+$type = $schema->find_type('Test' , 'testComplexTypeSequence');
+$element = $type->get_element()->[0];
+
+is $element->get_minOccurs() , 1, "minOccurs default for sequence";
+is $element->get_maxOccurs() , 1, "maxOccurs default for sequence";
--- a/t/009_data_classes.t
+++ b/t/009_data_classes.t
@@ -0,0 +1,97 @@
+#!/usr/bin/perl -w
+use strict;
+use Test::More tests => 5;
+use lib 't/lib';
+use lib '../lib';
+use lib 'lib';
+use Benchmark;
+use XML::Simple;
+use SOAP::WSDL::SAX::WSDLHandler;
+use Cwd;
+use XML::LibXML::SAX;
+use_ok(qw/SOAP::WSDL::SAX::MessageHandler/);
+
+use SOAP::WSDL;
+use SOAP::WSDL::XSD::Typelib::Builtin;
+my $path = cwd;
+$path =~s|\/t\/?$||;      # allow running from t/ and above (Build test)
+
+$XML::Simple::PREFERRED_PARSER = 'XML::Parser';
+
+my $filter;
+ok($filter = SOAP::WSDL::SAX::MessageHandler->new( {
+    class_resolver => FakeResolver->new(),
+} ), "Object creation");
+
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+$parser->parse_string( xml() );
+
+# print $filter->get_data();
+# print $filter->get_data()->get_MMessage()->_DUMP();
+
+if($filter->get_data()->get_MMessage()->get_MDeliveryReportRecipientURI()) {
+    pass "bool context overloading";
+}
+else
+{
+    fail "bool context overloading"
+}
+
+my $soap = SOAP::WSDL->new(
+    readable => 1,
+    wsdl => 'file:///' . $path .'/t/acceptance/wsdl/006_sax_client.wsdl',
+)->wsdlinit();
+
+$soap->servicename('MessageGateway');
+
+ok( $soap->no_dispatch( 1 ) , "Set no_dispatch" );
+ok( $soap->readable( 0 ) , "Set readable");
+
+timethese 100, {
+    'ClassParser' => sub { $parser->parse_string( xml() ); },
+    'XML::Simple' => sub { return XMLin( xml() ) },
+};
+
+sub xml {
+q{<SOAP-ENV:Envelope
+        xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+        xmlns:tns="http://www.example.org/MessageGateway2/"
+        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+        xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body ><EnqueueMessage><MMessage>
+                <MRecipientURI>mailto:test@example.com</MRecipientURI>
+                <MMessageContent>TestContent for Message</MMessageContent>
+                <MMessageContent>TestContent for Message 2</MMessageContent>
+                <MSenderAddress>martin.kutter@example.com</MSenderAddress>
+                <MDeliveryReportRecipientURI>mailto:test@example.com</MDeliveryReportRecipientURI>
+    </MMessage></EnqueueMessage></SOAP-ENV:Body></SOAP-ENV:Envelope>};
+}
+
+# data classes reside in t/lib/Typelib/
+BEGIN {
+    package FakeResolver;
+    {
+        my %class_list = (
+            'EnqueueMessage' => 'Typelib::TEnqueueMessage',
+            'EnqueueMessage/MMessage' => 'Typelib::TMessage',
+            'EnqueueMessage/MMessage/MRecipientURI' => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI',
+            'EnqueueMessage/MMessage/MMessageContent' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+            'EnqueueMessage/MMessage/MSenderAddress' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+            'EnqueueMessage/MMessage/MMessageContent' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
+            'EnqueueMessage/MMessage/MDeliveryReportRecipientURI' => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI',
+        );
+
+        sub new { return bless {}, 'FakeResolver' };
+
+        sub get_class {
+            my $name = join('/', @{ $_[1] });
+            return ($class_list{ $name }) ? $class_list{ $name }
+                : warn "no class found for $name";
+        };
+    };
+
+
+};
--- a/t/011_simpleType.t
+++ b/t/011_simpleType.t
@@ -0,0 +1,36 @@
+#!/usr/bin/perl
+use Test::More qw(no_plan);
+use strict;
+use lib 'lib/';
+use lib 't/lib/';
+use lib '../lib/';
+
+use_ok qw(MySimpleType);
+
+# simple type derived from builtin via restriction
+my $obj = MySimpleType->new({ value => 'test'});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
+    , 'inherited class';
+is $obj, 'test', 'stringification';
+
+# simple type derived from builtin via list
+$obj = MySimpleListType->new({ value => [ 'test', 'test2' ]});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
+    , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::list')
+    , 'inherited class';
+is $obj, 'test test2', 'stringification';
+
+# simple type derived from atomic simple type (restriction)
+$obj = MyAtomicSimpleType->new({ value => 'test' });
+ok $obj->isa('MySimpleType') , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::SimpleType::restriction')
+    , 'inherited class';
+is $obj, 'test', 'stringification';
+
+# simple type derived from atomic simple type (list)
+$obj = MyAtomicSimpleListType->new({ value => [ 'test', 'test2' ] });
+ok $obj->isa('MySimpleListType') , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::SimpleType::restriction')
+    , 'inherited class';
+is $obj, 'test test2', 'stringification';
--- a/t/012_element.t
+++ b/t/012_element.t
@@ -0,0 +1,70 @@
+#!/usr/bin/perl
+use Test::More qw(no_plan);
+use strict;
+use lib 'lib/';
+use lib '../lib/';
+use lib 't/lib';
+
+use_ok qw(SOAP::WSDL::XSD::Typelib::Element);
+use_ok qw( MyElement );
+
+# simple type derived from builtin via restriction
+my $obj = MyElement->new({ value => 'test'});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
+    , 'inherited class';
+is $obj, '<MyElementName xmlns="urn:Test" >test</MyElementName>', 'stringification';
+
+$obj = MyAtomicComplexTypeElement->new({ test=> 'Test', test2 => 'Test2'});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
+    , 'inherited class';
+
+ok $obj->get_test->isa('SOAP::WSDL::XSD::Typelib::Builtin::string')
+    , 'element isa';
+
+is $obj, '<MyAtomicComplexTypeElement xmlns="urn:Test" ><test >Test</test>'
+    . '<test2 >Test2</test2></MyAtomicComplexTypeElement>'
+    , 'stringification';
+
+$obj = MyElement->new({ value => undef});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
+    , 'inherited class';
+
+# is $obj, '<MyElementName xmlns="urn:Test" xsi:nil="true" />', 'nillable stringification';
+
+$obj = MyAtomicComplexTypeElement->new({ test=> 'Test', test2 => [ 'Test2', 'Test3' ]});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
+    , 'inherited class';
+is $obj, '<MyAtomicComplexTypeElement xmlns="urn:Test" ><test >Test</test>'
+    . '<test2 >Test2</test2>'
+    . '<test2 >Test3</test2>'
+    . '</MyAtomicComplexTypeElement>'
+    , 'multi value stringification';
+
+use diagnostics;
+
+ok $obj = MyComplexTypeElement->new({ MyTestName => 'test' });
+is $obj, '<MyComplexTypeElement xmlns="urn:Test" ><MyTestName >test</MyTestName ></MyComplexTypeElement>';
+
+__END__
+
+# simple type derived from builtin via list
+$obj = MySimpleListType->new({ value => [ 'test', 'test2' ]});
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
+    , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::list')
+    , 'inherited class';
+is $obj, 'test test2', 'stringification';
+
+# simple type derived from atomic simple type (restriction)
+$obj = MyAtomicSimpleType->new({ value => 'test' });
+ok $obj->isa('MySimpleType') , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::SimpleType::restriction')
+    , 'inherited class';
+is $obj, 'test', 'stringification';
+
+# simple type derived from atomic simple type (list)
+$obj = MyAtomicSimpleListType->new({ value => [ 'test', 'test2' ] });
+ok $obj->isa('MySimpleListType') , 'inherited class';
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::SimpleType::restriction')
+    , 'inherited class';
+is $obj, 'test test2', 'stringification';
--- a/t/013_complexType.t
+++ b/t/013_complexType.t
@@ -0,0 +1,44 @@
+#!/usr/bin/perl
+use Test::More qw(no_plan);
+use strict;
+use lib 'lib/';
+use lib '../lib/';
+use lib 't/lib';
+
+use_ok qw(SOAP::WSDL::XSD::Typelib::ComplexType);
+use_ok qw( MyComplexType );
+# simple type derived from builtin via restriction
+my $obj = MyComplexType->new({ MyTestName => 'test' });
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
+    , 'inherited class';
+is $obj, '<MyTestName >test</MyTestName >', 'stringification';
+
+$obj = MyComplexType->new({ MyTestName => [ 'test', 'test2' ] });
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
+    , 'inherited class';
+is $obj, '<MyTestName >test</MyTestName ><MyTestName >test2</MyTestName >',
+    'stringification';
+
+# try on the fly factory
+@MyComplexType2::ISA = ('SOAP::WSDL::XSD::Typelib::ComplexType');
+{
+    use Class::Std::Storable;
+    my %MyTestName_of;
+
+    MyComplexType2->_factory(
+        [ qw(MyTestName) ],                # order
+        { MyTestName => \%MyTestName_of },  # attribute lookup map
+        { MyTestName => 'MyElement' }       # class name lookup map
+    );
+}
+
+$obj = MyComplexType2->new({ MyTestName => [ 'test', 'test2' ] });
+ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType')
+    , 'inherited class (on the fly-factory object)';
+is $obj, '<MyTestName >test</MyTestName><MyTestName >test2</MyTestName>',
+    'stringification (on the fly-factory object)';
+# print Dumper $obj->get_MyTestName();
+
+
+__END__
+
--- a/t/014_sax_typelib.t
+++ b/t/014_sax_typelib.t
@@ -0,0 +1,375 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More tests => 16;
+use lib '../lib';
+use XML::SAX::ParserFactory;
+
+use diagnostics;
+
+eval {
+    require Test::XML;
+    import Test::XML;
+};
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
+
+use XML::LibXML;
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+eval { $parser->parse_string( xml() ) };
+if ($@)
+{
+	fail("parsing WSDL");
+	die "Can't test without parsed WSDL: $@";
+}
+else
+{
+	pass("parsing XML");
+}
+
+
+my $TMessage;
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+my %content;
+
+for my $element (@{ $wsdl->first_types()->get_schema()->[1]->get_type() } ) {
+    local $SIG{__WARN__} = sub {
+      like $_[0], qr{toClass \s is \s deprecated}xms, 'deprecated method warning';
+    };
+    my $output;
+    $element->to_class({ prefix => 'MessageGateway::', wsdl => $wsdl, 
+            output => \$output
+        });   
+    
+    # skip eval'ing TMessage - it requires evalling other 
+    # types first
+    if ($element->get_name() =~ m{\A (TMessage|TEnqueueMessage) \Z}xmsg ) {
+      $content{$1} = $output;
+      next;
+    }
+    my $name = 'MessageGateway::' . $element->get_name();
+    ok eval $output, $name;
+
+    ok $name->can('serialize'), "$name\->can('serialize')";
+}
+
+while ( my ($name, $code) = (each %content) ) {
+  ok eval "$code", $name;
+}
+
+ok MessageGateway::TMessage->can('serialize'), 'MessageGateway::TMessage->can("serialize")';
+ok MessageGateway::TEnqueueMessage->can('serialize'), "MessageGateway::TEnqueueMessage->can('serialize')";
+
+sub xml {
+	return q{<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions name="MessageGateway"
+  targetNamespace="http://www.example.org/MessageGateway2/"
+  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:tns="http://www.example.org/MessageGateway2/"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
+  <wsdl:types>
+    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+      xmlns:tns="http://www.example.org/MessageGateway2/"
+      targetNamespace="http://www.example.org/MessageGateway2/">
+
+      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+      <xsd:complexType name="TMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A type containing all elements of a message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
+                phone:. Not all URI schemas need to be implemented at the current
+                implementation stage.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                E-Mail sender address. Ignored for all but mailto: recipient URIs.
+              </xsd:documentation>
+
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>Message Content.</xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
+
+            <xsd:annotation>
+              <xsd:documentation>
+                Message Subject. Ignored for all but mailto: URIs
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+
+                URI to send a delivery report to. May be of one of the following schemes:
+                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
+                reports to http(s) URIs are sent as SOAP requests following the
+                MessageGatewayClient service definition.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                Container for keepalive information. May be missing.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepalive">
+        <xsd:annotation>
+          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+
+          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
+            <xsd:annotation>
+              <xsd:documentation>
+                Keepalive timeout. The keepalive timeout spezifies how long the sending of
+                a message will be delayed waiting for keepalive updates. If a keepalive
+                update is received during this period, the timeout will be reset. If not,
+                the message will be sent after the timeout has expired.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                Policy to comply to in case of system errors. Valid values are "suppress"
+                and "report". If the policy is set to "suppress", keepalive messages will
+                not be sent to their recipients in case of partial system failure, even if
+                the keepalive has expired. This may result in "false negatives", i.e.
+                messages may not be sent, even though their keepalive has expired. If the
+                value is "report", keepalive messages will be sent from any cluster node.
+                This may result in "false positive" alerts.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="suppress"></xsd:enumeration>
+                <xsd:enumeration value="report"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Type containing a message ID.</xsd:documentation>
+        </xsd:annotation>
+
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepliveMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            Type containing all elements of a keppalive update / remove request.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The ID for the message to update / remove
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The action to perform. Valid values are: "remove", "update". On "remove",
+                the message with the ID specified will be removed from the queue, thus it
+                will never be sent, even if it's timeout expires. On "update" the
+                keepalive timeout of the corresponding message will be reset.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="remove"></xsd:enumeration>
+                <xsd:enumeration value="update"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>Keepalive message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message response element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+
+      <xsd:complexType name="TEnqueueMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessage" type="tns:TMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a message to enqueue.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+
+      <xsd:complexType name="TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The keepalive message to process.
+          </xsd:documentation>
+
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a keepalive message to process.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+        </xsd:sequence>
+      </xsd:complexType>
+    </xsd:schema>
+  </wsdl:types>
+  <wsdl:message name="EnqueueMessageRequest">
+    <wsdl:part name="parameters" element="tns:EnqueueMessage">
+      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+
+  </wsdl:message>
+  <wsdl:message name="EnqueueMessageResponse">
+    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
+      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageRequest">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
+
+      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageResponse">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
+      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+
+  <wsdl:portType name="MGWPortType">
+    <wsdl:documentation>
+      generic port type for all methods required for sending messages over the 
+      message gatewa
+    </wsdl:documentation>
+    <wsdl:operation name="EnqueueMessage">
+      <wsdl:documentation>
+        This method is used to enqueue a normal (immediate send) or a delayed message with
+        keepalive functionality.
+      </wsdl:documentation>
+      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
+
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <wsdl:documentation>
+        This method is used to update or remove a
+        keepalive message.
+      </wsdl:documentation>
+      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
+    </wsdl:operation>
+  </wsdl:portType>
+
+  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
+    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
+    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="EnqueueMessage">
+      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <soap:operation
+        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:service name="MessageGateway">
+    <wsdl:documentation>
+      Web Service for sending messages over the message gatewa
+    </wsdl:documentation>
+
+    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
+      <wsdl:documentation>HTTP(S) port for the message gatewa</wsdl:documentation>
+      <soap:address location="https://www.example.org/MessageGateway/" />
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>};
+}
--- a/t/015_to_typemap.t
+++ b/t/015_to_typemap.t
@@ -0,0 +1,346 @@
+#!/usr/bin/perl -w
+use strict;
+use warnings;
+use Test::More tests => 5;
+use lib '../lib';
+use XML::SAX::ParserFactory;
+
+use diagnostics;
+
+eval {
+    require Test::XML;
+    import Test::XML;
+};
+
+use_ok(qw/SOAP::WSDL::SAX::WSDLHandler/);
+
+my $filter;
+
+ok($filter = SOAP::WSDL::SAX::WSDLHandler->new(), "Object creation");
+
+use XML::LibXML;
+my $parser = XML::LibXML->new();
+$parser->set_handler( $filter );
+
+eval { $parser->parse_string( xml() ) };
+if ($@)
+{
+	fail("parsing WSDL");
+	die "Can't test without parsed WSDL: $@";
+}
+else
+{
+	pass("parsing XML");
+}
+
+my $wsdl;
+ok( $wsdl = $filter->get_data() , "get object tree");
+
+ok $wsdl->to_typemap( { prefix => 'CP::EAI::Typelib::' } ), 'typemap';
+exit;
+
+sub xml {
+	return q{<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions name="MessageGateway"
+  targetNamespace="http://www.example.org/MessageGateway2/"
+  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+  xmlns:tns="http://www.example.org/MessageGateway2/"
+  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
+  <wsdl:types>
+    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+      xmlns:tns="http://www.example.org/MessageGateway2/"
+      targetNamespace="http://www.example.org/MessageGateway2/">
+
+      <xsd:element name="EnqueueMessage" type="tns:TEnqueueMessage">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+      <xsd:complexType name="TMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A type containing all elements of a message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MRecipientURI" type="xsd:anyURI" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                The recipient in URI notaitions. Valid URI schemas are: mailto:, sms:,
+                phone:. Not all URI schemas need to be implemented at the current
+                implementation stage.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSenderAddress" type="xsd:string" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                E-Mail sender address. Ignored for all but mailto: recipient URIs.
+              </xsd:documentation>
+
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MMessageContent" type="xsd:string" minOccurs="1"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>Message Content.</xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MSubject" type="xsd:string" minOccurs="0" maxOccurs="1">
+
+            <xsd:annotation>
+              <xsd:documentation>
+                Message Subject. Ignored for all but mailto: URIs
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MDeliveryReportRecipientURI" type="xsd:anyURI" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+
+                URI to send a delivery report to. May be of one of the following schemes:
+                mailto:, http:, https:. Reports to mailto: URIs are sent as plaintext,
+                reports to http(s) URIs are sent as SOAP requests following the
+                MessageGatewayClient service definition.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepalive" type="tns:TKeepalive" minOccurs="0"
+            maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                Container for keepalive information. May be missing.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepalive">
+        <xsd:annotation>
+          <xsd:documentation>Type containing keeplive information.</xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+
+          <xsd:element name="MKeepaliveTimeout" type="xsd:double">
+            <xsd:annotation>
+              <xsd:documentation>
+                Keepalive timeout. The keepalive timeout spezifies how long the sending of
+                a message will be delayed waiting for keepalive updates. If a keepalive
+                update is received during this period, the timeout will be reset. If not,
+                the message will be sent after the timeout has expired.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+          <xsd:element name="MKeepaliveErrorPolicy" minOccurs="0" maxOccurs="1">
+            <xsd:annotation>
+
+              <xsd:documentation>
+                Policy to comply to in case of system errors. Valid values are "suppress"
+                and "report". If the policy is set to "suppress", keepalive messages will
+                not be sent to their recipients in case of partial system failure, even if
+                the keepalive has expired. This may result in "false negatives", i.e.
+                messages may not be sent, even though their keepalive has expired. If the
+                value is "report", keepalive messages will be sent from any cluster node.
+                This may result in "false positive" alerts.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="suppress"></xsd:enumeration>
+                <xsd:enumeration value="report"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Type containing a message ID.</xsd:documentation>
+        </xsd:annotation>
+
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1"></xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+      <xsd:complexType name="TKeepliveMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            Type containing all elements of a keppalive update / remove request.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessageID" type="xsd:string" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The ID for the message to update / remove
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+          <xsd:element name="MAction" minOccurs="1" maxOccurs="1">
+            <xsd:annotation>
+              <xsd:documentation>
+                The action to perform. Valid values are: "remove", "update". On "remove",
+                the message with the ID specified will be removed from the queue, thus it
+                will never be sent, even if it's timeout expires. On "update" the
+                keepalive timeout of the corresponding message will be reset.
+              </xsd:documentation>
+            </xsd:annotation>
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="remove"></xsd:enumeration>
+                <xsd:enumeration value="update"></xsd:enumeration>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+      <xsd:element name="KeepaliveMessage" type="tns:TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>Keepalive message request element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="KeepaliveMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Response element for a keepalive request</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="EnqueueMessageResponse" type="tns:TMessageID">
+        <xsd:annotation>
+          <xsd:documentation>Enqueue message response element</xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+
+
+      <xsd:complexType name="TEnqueueMessage">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The message to enqueue.
+          </xsd:documentation>
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MMessage" type="tns:TMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a message to enqueue.
+              </xsd:documentation>
+            </xsd:annotation>
+
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+
+
+      <xsd:complexType name="TKeepaliveMessageRequest">
+        <xsd:annotation>
+          <xsd:documentation>
+            A complex type containing one element: The keepalive message to process.
+          </xsd:documentation>
+
+        </xsd:annotation>
+        <xsd:sequence>
+          <xsd:element name="MKeepaliveMessage" type="tns:TKeepliveMessage">
+            <xsd:annotation>
+              <xsd:documentation>
+                Element containing a keepalive message to process.
+              </xsd:documentation>
+            </xsd:annotation>
+          </xsd:element>
+
+        </xsd:sequence>
+      </xsd:complexType>
+    </xsd:schema>
+  </wsdl:types>
+  <wsdl:message name="EnqueueMessageRequest">
+    <wsdl:part name="parameters" element="tns:EnqueueMessage">
+      <wsdl:documentation>inputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+
+  </wsdl:message>
+  <wsdl:message name="EnqueueMessageResponse">
+    <wsdl:part name="parameters" element="tns:EnqueueMessageResponse">
+      <wsdl:documentation>outputparameters for EnqueueMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageRequest">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessage">
+
+      <wsdl:documentation>input parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+  <wsdl:message name="KeepaliveMessageResponse">
+    <wsdl:part name="parameters" element="tns:KeepaliveMessageResponse">
+      <wsdl:documentation>output parameters for KeepaliveMessag</wsdl:documentation>
+    </wsdl:part>
+  </wsdl:message>
+
+  <wsdl:portType name="MGWPortType">
+    <wsdl:documentation>
+      generic port type for all methods required for sending messages over the mosaic
+      message gatewa
+    </wsdl:documentation>
+    <wsdl:operation name="EnqueueMessage">
+      <wsdl:documentation>
+        This method is used to enqueue a normal (immediate send) or a delayed message with
+        keepalive functionality.
+      </wsdl:documentation>
+      <wsdl:input message="tns:EnqueueMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:EnqueueMessageResponse"></wsdl:output>
+
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <wsdl:documentation>
+        This method is used to update or remove a
+        keepalive message.
+      </wsdl:documentation>
+      <wsdl:input message="tns:KeepaliveMessageRequest"></wsdl:input>
+      <wsdl:output message="tns:KeepaliveMessageResponse"></wsdl:output>
+    </wsdl:operation>
+  </wsdl:portType>
+
+  <wsdl:binding name="MGWBinding" type="tns:MGWPortType">
+    <wsdl:documentation>Generic binding for all (SOAP) port</wsdl:documentation>
+    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="EnqueueMessage">
+      <soap:operation soapAction="http://www.example.org/MessageGateway2/EnqueueMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="KeepaliveMessage">
+      <soap:operation
+        soapAction="http://www.example.org/MessageGateway2/KeepaliveMessage" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:service name="MessageGateway">
+    <wsdl:documentation>
+      Web Service for sending messages over the mosaic message gatewa
+    </wsdl:documentation>
+
+    <wsdl:port name="HTTPPort" binding="tns:MGWBinding">
+      <wsdl:documentation>HTTP(S) port for the mosaic message gatewa</wsdl:documentation>
+      <soap:address location="https://www.example.org/MessageGateway/" />
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>};
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Martin Kutter	25548e6296	import SOAP-WSDL 2.00_06 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_06 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_06.tar.gz	2009-12-12 19:47:44 -08:00
Martin Kutter	a78d6d15b5	import SOAP-WSDL 2.00_05 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_05 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_05.tar.gz	2009-12-12 19:47:43 -08:00
Martin Kutter	5c42b1d8f6	import SOAP-WSDL 2.00_04 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_04 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_04.tar.gz	2009-12-12 19:47:43 -08:00
Martin Kutter	21b5330a8d	import SOAP-WSDL 2.00_03 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_03 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_03.tar.gz	2009-12-12 19:47:42 -08:00
Martin Kutter	7716d4349a	import SOAP-WSDL 2.00_02 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_02 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_02.tar.gz	2009-12-12 19:47:41 -08:00
Martin Kutter	6fe52c4370	import SOAP-WSDL 2.00_01 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 2.00_01 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_01.tar.gz	2009-12-12 19:47:41 -08:00
Martin Kutter	bfbf5e27e0	import SOAP-WSDL 1.23 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 1.23 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-1.23.tar.gz	2009-12-12 19:47:40 -08:00
Martin Kutter	903b3e95e4	import SOAP-WSDL 1.22 from CPAN git-cpan-module: SOAP-WSDL git-cpan-version: 1.22 git-cpan-authorid: MKUTTER git-cpan-file: authors/id/M/MK/MKUTTER/SOAP-WSDL-1.22.tar.gz	2009-12-12 19:47:39 -08:00